Model reference · open weights

Falcon3-prequantized

LLMs tiiuae Text gen 1 build Its own licence terms 322 dl/mo

Falcon3-prequantized is an open-weight language model from tiiuae. Falcon3-10B-Base-1.58bit-prequantized (BF16) weighs 20.6 GB; the smallest configuration that runs it is RTX 4090 24 GB.

What it is

Released bytiiuae
TypeLanguage models
TaskText gen
Parameters (lead)10.3B
Context32,768 tokens
Runs withtransformers
Based ontiiuae/Falcon3-10B-Base
Released2026-04-30
Popularity322 downloads / month
Weights20.6 GB (Falcon3-10B-Base-1.58bit-prequantized (BF16), file size)
LicenceIts own licence terms

What it runs on

Memory and cards for Falcon3-10B-Base-1.58bit-prequantized (BF16)

Weights 20.6 GB (file size) · KV cache 164 MB per 1,000 tokens of context, at 16 bits (vLLM's default for this build; an 8-bit cache halves it) · runtime overhead from 803 MB on a small card · context up to 32,768 tokens.

CardRequests at once
8K tokens each
Requests at once
32K tokens each
Longest single
request
Counted
memory
RTX 3060 12 GB … RTX 4060 Ti 16 GB
2 smaller cards
———
RTX 3090 24 GB1—11K23.4 GB
RTX 4090 24 GB1—11K23.4 GB
RTX 5090 32 GB71all 32K31.0 GB
L40S 48 GB164all 32K44.0 GB
A100 80 GB4210all 32K78.2 GB
H100 80 GB399all 32K78.1 GB
RTX PRO 6000 Blackwell 96 GB5012all 32K93.8 GB
DGX Spark (GB10) 128 GB unified6015all 32K107 GB
H200 141 GB8320all 32K138 GB
B200 180 GB11127all 32K176 GB
2× RTX 4060 Ti 16 GB
tensor parallel
61all 32K15.4 GB a card
2× RTX 4090 24 GB
tensor parallel
184all 32K23.4 GB a card
2× RTX 3090 24 GB
tensor parallel
184all 32K23.4 GB a card
2× RTX 5090 32 GB
tensor parallel
297all 32K31.0 GB a card
Memory needed at each load
Requests at once8K tokens each32K tokens each
122.8 GB26.8 GB
528.1 GB48.3 GB
832.2 GB64.4 GB
1642.9 GB107 GB
3264.4 GB193 GB
64107 GB365 GB

On one card, with vLLM's small-card settings (2,048 tokens a step). Cards of 70 GB and more reserve more per request and more overhead — each row above uses its own card's settings.

Estimates, not measurements, checked against published vLLM startup logs. The weights are the build's file size; the cache is calculated from its config (grouped-query attention); the overhead is an estimate of vLLM's own memory with that card's default settings. "Requests at once" is how many requests of that length vLLM admits — its reservation at full length, with --max-model-len set to that length; requests that stay shorter fit more. "Longest single request" is the most one request can hold there: below the model's maximum, vLLM starts only with --max-model-len set at or under it. "Counted memory" is vLLM's default 92 % of what CUDA reports for the card (the DGX Spark: about 100 GiB of its shared 128 GB). A tensor-parallel split pools the cards' memory and speeds each token up, at the cost of the link between them; a layer split (llama.cpp) holds more but does not make one request faster. Assumes vLLM 0.10 or later.

From the model card

What tiiuae says about Falcon3-prequantized

  1. TL;DR
  2. Model Details
  3. Training Details
  4. Usage
  5. Evaluation
  6. Citation

TL;DR

Model Details

This is a 'hacked' version of tiiuae/Falcon3-10B-Base-1.58bit where model weight scales have been injected into ternary model weights in order to make the model compatible with fine-tuning

Read the full model card

Model Description

  • Developed by: https://www.tii.ae
  • Model type: Causal decoder-only
  • Architecture: Pure-transformer - 1.58bit version
  • Language(s) (NLP): Mainly English
  • License: TII Falcon License 2.0

Training details

The model has been trained following the training strategies from the recent 1-bit LLM HF blogpost and 1-bit LLM paper. For more details about the training protocol of this model, please refer to the Falcon-3 technical report, section Compression.

Usage

Currently to use this model you can either rely on Hugging Face transformers library or BitNet library. You can also play with the model using the falcon-1.58bit playground (only for the 7B instruct version).

🤗 transformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "tiiuae/Falcon3-10B-Base-1.58bit"

model = AutoModelForCausalLM.from_pretrained(
  model_id,
  torch_dtype=torch.bfloat16,
).to("cuda")

# Perform text generation

BitNet

git clone https://github.com/microsoft/BitNet && cd BitNet
pip install -r requirements.txt
python setup_env.py --hf-repo tiiuae/Falcon3-10B-Base-1.58bit -q i2_s
python run_inference.py -m models/Falcon3-10B-1.58bit/ggml-model-i2_s.gguf -p "You are a helpful assistant" -cnv

Evaluation

We report in the following table our internal pipeline benchmarks:

Note evaluation results are normalized score from v2 leaderboard tasks - reported results of original models in the blogpost are raw scores

Citation

Coming soon ..

Quoted from the model card on Hugging Face — the full card is behind the Hugging Face link above.

© 2026 AxForge · EU-hosted AI infrastructure Pricing Docs Trust Privacy Terms