That combination — weak Bangla support and heavy hardware requirements — is the problem RIFA was built to solve.

Starting From a Different Question

Instead of asking "how do we make the biggest model possible," RIFA started from a narrower, more practical question: what's the smallest model that can still hold a real conversation in both English and Bangla, on hardware a normal developer actually owns?

That question shaped everything about how the project turned out. Rather than one flagship model, it became five — each one tuned for a different constraint, not a different market segment.

Five Models, Five Constraints

• Rifa-Nano (0.5B) exists for one reason: run anywhere. It's fine-tuned from Qwen2.5-0.5B-Instruct and carries dedicated anti-hallucination training, so instead of confidently making things up when it doesn't know an answer, it's more likely to say so. That matters more at 0.5B than almost any other design choice — a tiny model that's honest about its limits is far more usable than one that guesses convincingly.

• RIFA-CODE (0.6B) narrows the focus further, toward code completion and short scripts. It's not trying to compete with large code models — it's trying to be useful on a machine that couldn't run one anyway. RIFA-Edge (0.6B) is built around a single constraint: no GPU. CPU-first inference, tuned for edge and embedded deployment, where "efficient" isn't a nice-to-have, it's the whole point.

• RIFA-FLASH (1.7B) is the model most people should probably start with. It's the point in the series where quality starts to noticeably improve, while it's still light enough for real-time, interactive chat.

• RIFA-PRO (3B) is the top of the range — still small by industry standards, but the model to reach for when output quality matters more than shaving off the last bit of memory or latency.

Four Rules That Shaped the Project

Everything in RIFA was built against four constraints:

• Efficient — if it doesn't run on modest hardware, it doesn't belong in the series Capable — every model has to be genuinely useful for its size class, not just small for the sake of being small

• Yours — full open weights, Apache 2.0 licensed, documented well enough that someone else can pick it up and actually use it

• Honest — small models have real limits, and pretending otherwise helps no one

That last point is the one most projects skip. It's easier to market a small model as "surprisingly capable" than to say plainly: this is a 0.5B parameter model, it will get things wrong, verify anything that matters.

Running It Yourself

Every model ships two ways: full Safetensors weights for anyone working in Hugging Face Transformers, and GGUF quantizations for fully offline use in Ollama, LM Studio, or llama.cpp. If you're not sure where to start, Q5_K_M is the quantization that tends to balance quality and size best across the lineup.

Where the Line Actually Is

None of the RIFA models will out-reason a frontier-scale LLM, and they're not supposed to. Multi-step reasoning, obscure domains, very recent events — that's where the cracks show. The anti-hallucination training in Rifa-Nano helps it recognize when it's out of its depth, but it doesn't make the model know more than it does. Treat these as fast, private, offline-capable assistants for everyday tasks — not a research assistant for anything high-stakes.

Who's Behind It

RIFA is an independent project by SM Shahbaj, published on Hugging Face as smshahbaj — built out of the same everyday need it tries to solve: wanting a model that speaks Bangla properly and doesn't need a data center to run.

Links Collection: huggingface.co/collections/smshahbaj/rifa-text-series

Docs scripts: github.com/smshahbaj/RIFA-Text-Series

Rifa-Nano-0.5B: huggingface.co/smshahbaj/Rifa-Nano-0.5B

RIFA-CODE-0.6B: huggingface.co/smshahbaj/RIFA-CODE-0.6B

RIFA-Edge-0.6B: huggingface.co/smshahbaj/RIFA-Edge-0.6B

RIFA-FLASH-1.7B: huggingface.co/smshahbaj/RIFA-FLASH-1.7B

RIFA-PRO-3B: huggingface.co/smshahbaj/RIFA-PRO-3B

Paper: doi.org/10.6084/m9.figshare.33941830