The Italian LLM Landscape in 2025: Models, Ecosystem, and Practical Choices

What "Italian LLM" means: three different routes

Three very different things live under the same label, and mixing them up leads to wrong comparisons. A model can be trained from scratch with a large share of Italian, in which case Italian is in the data from the very first step. It can be an adapted multilingual model: it starts from a model built by others (for example Llama 3) and is fine-tuned with Italian instructions. Or it can be multilingual by construction, with Italian as one language among six.

The practical difference lies on three axes: how much Italian it saw in pre-training, how much you can trust the documentation of the data, and which licence constraints you inherit from the starting model. An adapted model inherits the licence of whoever built it; a model from scratch gets the licence its trainer chooses. For this reason the table below does not rank the models by quality: it orders them by size and reports the facts the card declares, leaving blank whatever I could not read.

The four models, from the official card

The data below were read from the model pages on Hugging Face on 2026-11-12 (addresses in the Sources), not from third-party articles. Where the card does not say something, the cell says "not read" and I have not filled the gap.

The most useful fact in the table is an absence: only two rows out of four say what data the model was built on. Minerva documents it down to the individual sources (RedPajama-Data-V2, CulturaX, Wikipedia, Gazzetta Ufficiale, EurLex), while for Modello Italia the card of the conversion states that the training data are unknown. If your work requires knowing what the model was trained on, for example to assess the risk of test contamination or of protected content, this row weighs more than any score.

Minerva: the only one trained from scratch and documented

The card of Minerva-7B-instruct-v1.0 presents it as the first family of models trained from scratch on Italian, developed by Sapienza NLP in the FAIR project with CINECA. The family has five models (350M, 1B, 3B and 7B base, plus the 7B instruct). The 7B was trained on almost 2.5 trillion tokens: 1.14 trillion in Italian, 1.14 in English and 200 billion of code. The architecture is Mistral's, and the declared licence is Apache 2.0.

Two details of the card change practical choices. The first: the maximum context of the 7B is 4096 tokens, against the 16384 of the smaller models in the same family, so for a RAG with many long passages the largest model is paradoxically the narrowest. The second: the instruct version is obtained with a supervised fine-tuning phase followed by a preference phase (online DPO), and the card itself warns that the model can still produce wrong or inappropriate content. For evaluation the card points to ITA-Bench, a collection of 18 Italian benchmarks published by the Sapienza group on Hugging Face.

LLaMAntino: a Llama 3 carried towards Italian

LLaMAntino-3-ANITA-8B is developed by Marco Polignano and the SWAP group at the University of Bari. It starts from Meta-Llama-3-8B-Instruct and fine-tunes it with 4-bit QLoRA on instruction datasets, then applies DPO to align the model with preferences for helpfulness and safety. The context is 8192 tokens and the licence is the Llama 3 one, which is not Apache: before using it in a product read Meta's conditions, because they apply to the derivative too.

The scores the card reports (ARC 74.57, HellaSwag 92.75, MMLU 66.85, TruthfulQA 75.93, Winogrande 82.0, GSM8k 58.61) come from the Open LLM Leaderboard, which measures in English. They say that the fine-tuning did not ruin the starting model, not that the Italian is better: for Italian the card reports no measurement. Reading those numbers as proof of quality in Italian is a frequent mistake.

Modello Italia: little documented, to be evaluated with caution

Modello Italia 9B is the first model by iGenius, developed in collaboration with CINECA. The original weights were trained with LitGPT, and the version usable with transformers is an unofficial conversion published by Sapienza NLP, which states that it reconstructed the information available. According to that card the training data are unknown, the tokenizer is a SentencePiece with a 50000-entry vocabulary, and using it requires accepting iGenius's terms in addition to the MIT licence declared on the repository. The safetensors metadata of the conversion report 8,537,420,800 parameters: that is the number I use in the calculations below, not "9 billion".

Velvet: two sizes, access on request

Velvet is Almawave's family, published in the AlmawaveLabs repository: Velvet-2B (English and Italian) and Velvet-14B (English, French, German, Spanish, Italian, Portuguese). Both have the Mistral architecture and the repository labels them Apache 2.0, but access is "gated": you must accept the conditions on the model page before downloading the weights, and without an account I cannot read the full card. As a result I tell you nothing about Velvet's context, data or scores: I have not read them, and I do not write what I do not know.

From the card to the calculation: how much memory you need

Before discussing quality, check whether the model fits. The memory of the weights alone is the product of parameters and bytes per weight: two bytes in fp16 or bf16, one in int8, half a byte with 4-bit quantization. The program below computes it for the models in the table. It does not count the cache of the tokens already processed (the KV cache), the activations and the runtime buffer, which add up and grow with the context: read the results as a minimum, never as the total.

# Memory estimate for the WEIGHTS ONLY: parameters x bytes per weight.
# It does not include the KV cache, activations, or runtime buffers.
BYTE_PER_PESO = {"fp16/bf16": 2.0, "int8": 1.0, "4 bit": 0.5}

# Parameters: 7e9 and 8e9 are the nominal values from the model cards; Modello Italia 9B
# uses the total reported by the safetensors metadata of the Hugging Face conversion.
MODELLI = {
    "Velvet-2B": 2e9,
    "Minerva-7B": 7e9,
    "LLaMAntino-3-ANITA-8B": 8e9,
    "Modello Italia 9B": 8_537_420_800,
    "Velvet-14B": 14e9,
}

def gigabyte(parametri, byte_per_peso):
    return parametri * byte_per_peso / 1e9  # decimal GB

intestazione = f"{'model':24}" + "".join(f"{k:>12}" for k in BYTE_PER_PESO)
print(intestazione)
for nome, n in MODELLI.items():
    riga = f"{nome:24}" + "".join(f"{gigabyte(n, b):>12.1f}" for b in BYTE_PER_PESO.values())
    print(riga)

# Output:
# model                      fp16/bf16        int8       4 bit
# Velvet-2B                        4.0         2.0         1.0
# Minerva-7B                      14.0         7.0         3.5
# LLaMAntino-3-ANITA-8B           16.0         8.0         4.0
# Modello Italia 9B               17.1         8.5         4.3
# Velvet-14B                      28.0        14.0         7.0

The lines that matter are the BYTE_PER_PESO table, which fixes the three precision assumptions, and the gigabyte function, which divides by 10⁹ and not by 2³⁰: these are decimal gigabytes, as graphics-card makers state them, not gibibytes. The output says concrete things. Velvet-14B in 4 bit weighs 7.0 GB and so fits on an 8 GB card for the weights alone, but with very little margin for the cache; Minerva-7B in fp16 weighs 14.0 GB and does not fit on a 12 GB card without quantizing. If you drop the exact parameter count for Modello Italia and use 9e9, you get 18.0 GB instead of 17.1: you are off by almost a gigabyte, and the reason is that "9B" is a rounding.

Turning constraints into a short list

The real constraints are few: the memory available, the precision you can go down to, the minimum context and the language. The next program writes them as arguments of a function and filters the four models. For each candidate it keeps what the card declares, and uses None where I did not read it: when you ask for a minimum context, an unknown context is excluded, because taking for granted what you do not know is the quickest way to discover the problem in production.

# A short list is a filter with the constraints written down: if you don't write them, you pick at random.
from dataclasses import dataclass

@dataclass(frozen=True)
class Candidato:
    nome: str
    miliardi: float          # parameters, in billions
    contesto: int | None     # context tokens declared by the model card; None = not read
    licenza: str             # as written on the model card
    lingue: tuple[str, ...]

CANDIDATI = (
    Candidato("Velvet-2B", 2.0, None, "apache-2.0 (access on request)", ("en", "it")),
    Candidato("Minerva-7B-instruct", 7.0, 4096, "apache-2.0", ("it", "en")),
    Candidato("LLaMAntino-3-ANITA-8B", 8.0, 8192, "llama3", ("en", "it")),
    Candidato("Modello Italia 9B", 8.54, None, "mit + iGenius terms", ("it",)),
    Candidato("Velvet-14B", 14.0, None, "apache-2.0 (access on request)", ("en", "fr", "de", "es", "it", "pt")),
)

def shortlist(max_gb, bit, contesto_min, lingua):
    out = []
    for c in CANDIDATI:
        gb = c.miliardi * bit / 8          # billions x bytes/weight = GB
        if gb > max_gb or lingua not in c.lingue:
            continue
        if contesto_min and (c.contesto is None or c.contesto < contesto_min):
            continue                       # unknown context: I don't take it for granted
        out.append((c.nome, round(gb, 1), c.licenza))
    return out

print("case A: 8 GB, 4 bit, no context constraint, Italian")
for r in shortlist(8, 4, 0, "it"): print("  ", r)
print("case B: 8 GB, 4 bit, at least 8192 context tokens, Italian")
for r in shortlist(8, 4, 8192, "it"): print("  ", r)
print("case C: 16 GB, 8 bit, no context constraint, Portuguese")
for r in shortlist(16, 8, 0, "pt"): print("  ", r)

# Output:
# case A: 8 GB, 4 bit, no context constraint, Italian
#    ('Velvet-2B', 1.0, 'apache-2.0 (access on request)')
#    ('Minerva-7B-instruct', 3.5, 'apache-2.0')
#    ('LLaMAntino-3-ANITA-8B', 4.0, 'llama3')
#    ('Modello Italia 9B', 4.3, 'mit + iGenius terms')
#    ('Velvet-14B', 7.0, 'apache-2.0 (access on request)')
# case B: 8 GB, 4 bit, at least 8192 context tokens, Italian
#    ('LLaMAntino-3-ANITA-8B', 4.0, 'llama3')
# case C: 16 GB, 8 bit, no context constraint, Portuguese
#    ('Velvet-14B', 14.0, 'apache-2.0 (access on request)')

Case A shows that in 8 GB, at 4 bit, all five candidates fit: the memory constraint alone does not decide. In case B it is enough to add a context of at least 8192 tokens and the list shrinks to LLaMAntino, the only one with that value declared by its card: Minerva-7B stops at 4096 and for the others there is no number read. Case C looks for Portuguese and returns only Velvet-14B, because it is the only one that lists it among its languages. The program does not say which is "better": it says which ones survive your constraints, which is the honest starting point before measuring quality on your own texts.

How to decide, in four questions

The sequence below is the order in which it pays to discard, from the hardest constraint to the softest. Changing the order changes the work, because the first two discard many candidates at no cost, while the last requires a real evaluation:

1. Licence and access. Apache 2.0 (Minerva), Llama 3 licence (LLaMAntino), iGenius terms (Modello Italia), access on request (Velvet): if a legal constraint rules a model out, the rest does not matter.
2. Memory and context. Run the weights calculation and compare it with the graphics card or RAM you actually have, leaving margin for the cache.
3. Documentation of the data. If you must be able to say what the model was trained on, Minerva is the only one of the four that documents it.
4. Quality on your texts. Build twenty or thirty questions typical of your case, with the expected answer, and compare the remaining models.

The last question is the only one no card can close for you. A score on a general benchmark measures a general task; your task (answering about contracts, summarizing tickets, classifying emails) has a vocabulary and a register of its own, and twenty real examples are worth more than a leaderboard. For the document retrieval part that feeds the model, the next step is RAG in Italian: Multilingual Embeddings and Semantic Retrieval.

What the leaderboards do not tell you

Figures such as comparative scores with three decimals, costs per token, the payback time of a GPU or the "points gained" with fine-tuning do not appear in the official cards I read, and for that reason I do not report them. If you need them, produce them yourself: memory with the program above, quality with your small test set, cost with the prices of your hardware or your provider on the date you decide. To adapt a model to your data see Fine-tuning an LLM for Italian: LoRA, Datasets, and Evaluation; for the level below the model, that is tokenization, lemmas and entities, Italian NLP with spaCy and Transformers: A Practical Pipeline. The overview of the previous year is in Italian LLMs in 2024: Minerva, LLaMAntino, and the First Native Models.

Frequently asked questions

Is an Italian LLM worth it instead of a large multilingual model?

It depends on the constraint that pinches you. If you have little memory and only Italian texts, a 7-8 billion model designed for Italian is a reasonable base; if you have plenty of memory and complex reasoning tasks, a much larger multilingual model remains a candidate to measure. There is no public Italian leaderboard that settles the matter: the answer comes from comparing the models on your own examples.

Which Italian model has the simplest licence?

Among the four, Minerva declares Apache 2.0 with no access conditions. LLaMAntino inherits the Llama 3 licence, Modello Italia requires accepting iGenius's terms, Velvet requires an access request. Always read the licence text on the model page at the moment you decide: it changes with versions.

What does quantizing to 4 bit mean?

It means representing each weight with about half a byte instead of two, and therefore dividing the memory of the weights by four compared with fp16, as the first program shows. The price is a loss of precision that depends on the method and the model: it must be measured on your examples, not assumed negligible.

Where do I find Italian benchmarks?

ITA-Bench is the collection of 18 Italian benchmarks published by Sapienza NLP on Hugging Face, used in the Minerva card. For the cards of the other models check which benchmarks they declare and in which language: the LLaMAntino scores quoted above, for example, are in English.

What you can do now

You can tell a model trained from scratch from an adapted one and understand what follows for data and licence, you can compute the minimum weight memory of a candidate in three precisions, and you can write your constraints as an executable filter instead of trusting a leaderboard. The next step is not choosing a name, but preparing the twenty examples you will test it with.