Apertus 8B

Apertus 8B is an 8-billion-parameter dense language model from EPFL, ETH Zurich, and the Swiss National Supercomputing Centre (CSCS), released in September 2025 under Apache 2.0. It is the smaller half of a two-model family (the other is a 70B sibling) and the one that fits on hardware you probably already own. What separates it from most open-weight releases is the scope of the openness: weights, training data, filtering pipeline, training code, and intermediate checkpoints are all published. You can inspect and reproduce the run, not just download the artifact.

The differentiator is multilingual coverage at a scale no comparable 8B model matches. Pretraining ran over 15 trillion tokens across more than 1,000 languages, with 40 percent of the corpus non-English. The Hugging Face card claims 1,811 natively supported languages, including Swiss German, Romansh, and a long tail that Llama, Qwen, and Gemma largely treat as an afterthought. If your workload is English-only reasoning, that breadth buys you little. If it is not, this is one of the few sub-10B options built for it.

Architecturally it stays conventional in the ways that matter for inference: decoder-only transformer, dense, no mixture-of-experts routing. Every one of the 8B parameters is active on every token, so memory footprint and throughput scale predictably with quantization level. The release also ships in two checkpoints: Apertus-8B-2509 (base) and Apertus-8B-Instruct-2509 (chat-tuned). For anything conversational, pull the instruct variant.

• Parameters: 8B, all active per token (dense)
• Architecture: decoder-only transformer
• Activation: xIELU, a custom function introduced with this model family
• Optimizer: AdEMAMix, trained from scratch rather than fine-tuned from an existing checkpoint
• Pretraining: 15T tokens, staged curriculum over web, code, and math data
• Post-training: supervised fine-tuning plus alignment via QRPO
• Modality: text-only
• License: Apache 2.0, including commercial use
• Context length: the release materials advertise long-context support, but no single fixed window figure is published in the model card

Dense is the right call at this size. There is no router to add latency or to make quantized inference behave unpredictably, and the KV cache grows linearly and predictably with context. The practical consequence is that a long-context session on an 8B dense model is memory-bound, not compute-bound: you can push context further than you would on a larger model, but you pay for it in VRAM.

The fully-open training stack matters for a narrower audience. If you need to audit what data went in, verify opt-out compliance, or fork the recipe for a domain-specific run, Apertus gives you the artifacts to do it. Almost no model at this size does.

Apertus 8B is a chat model with unusually wide language coverage. Concrete workloads it fits:

• Multilingual customer support: routing and first-line responses across European languages without a per-language model or a translation hop
• Translation, including low-resource pairs: Swiss German, Romansh, and other languages that mainstream 8B models handle poorly or not at all
• Multilingual retrieval-augmented generation: embedding-agnostic RAG where the generator must answer in the same language as the retrieved document
• On-premises assistants in regulated environments: Apache 2.0 plus documented provenance removes most of the legal review that closed models trigger
• Public-sector and educational tooling: the model was explicitly designed for this, and the compliance documentation is published alongside the weights

Be clear about the limits. It is text-only: no vision, no audio. It is not a frontier coding model, and on English reasoning benchmarks it will trail the strongest 7B-9B competitors. Treat it as a multilingual workhorse, not a general-purpose benchmark winner.

Memory is the first constraint. Rough weight footprints by quantization:

• BF16 / FP16: ~16 GB of weights, 18-20 GB total with a working KV cache
• Q8_0: ~8.5 GB
• Q6_K: ~6.6 GB
• Q5_K_M: ~5.7 GB
• Q4_K_M: ~4.9 GB (the sensible default)
• Q3_K_M: ~4.1 GB, with visible quality loss

Q4_K_M is the right starting point for most people. It costs a small amount of quality against Q8_0 and roughly halves the memory, which is the difference between "runs on a 12 GB card" and "does not." Step up to Q5_K_M or Q6_K only if you have headroom and are doing something quality-sensitive, such as translation into a low-resource language.

Hardware that realistically runs it:

• RTX 4090 (24 GB): BF16 with room to spare, or Q4_K_M with very long context
• RTX 4080 / 4070 Ti (16 GB): Q8_0, or Q4_K_M for longer sessions
• RTX 3060 12 GB: Q4_K_M comfortably, Q5_K_M if you keep context modest
• M4 Max (36-48 GB unified): BF16 at usable speed
• M2 / M3 with 16 GB unified: Q4_K_M, expect it to compete with other apps for memory
• CPU-only: Q4_K_M works, but throughput drops to single digits or low teens

Throughput ballparks for generation, single stream, Q4_K_M: roughly 100-130 tokens/sec on an RTX 4090, 45-60 on an RTX 3060 12 GB, 55-75 on an M4 Max, and 18-25 on a 16 GB M-series laptop. Context length and batch size move these numbers; benchmark your own prompt shape before committing.

Ollama is the fastest path to a working setup. It can pull GGUF builds directly from Hugging Face repos using the hf.co/ prefix, so you can point it at a community quantization of the instruct checkpoint and be chatting in a couple of minutes. For production serving, vLLM supports Apertus and will give you far better throughput under concurrency; note that it requires transformers 4.56.0 or later. llama.cpp and LM Studio both work if you prefer a local GUI or finer control over sampling.

Against Qwen3 8B: Qwen3 is the stronger generalist. It handles reasoning and code better, has a thinking mode, and ships under Apache 2.0 as well. Its language coverage is far narrower, in the low hundreds rather than low thousands. Pick Qwen3 when English and code quality dominate. Pick Apertus when the language list is the requirement.

Against Llama 3.1 8B: Llama has the larger ecosystem, more fine-tunes, and better tooling support out of the box, but it covers eight languages and ships under the Llama community license rather than Apache 2.0. If you need permissive licensing, documented training data, or non-English coverage, Apertus is the cleaner choice. If you need a drop-in model with a decade of community tooling behind it, Llama is.

The honest summary: Apertus 8B does not win on benchmark averages. It wins on language breadth, license clarity, and the fact that you can audit the entire training pipeline. Those are the reasons to choose it, and they are not small ones for teams building outside English.