Emma-6 (GGUF)

Preamble

This repository contains an unofficial GGUF conversion of egomnia/emma-6, made with llama.cpp.

The original Emma-6 model was developed by Egomnia S.p.A.. This repository is not affiliated with Egomnia S.p.A. and does not change the authorship of the original model.

Weights provenance

The GGUF files were converted from the official FP32 ONNX export published in egomnia/emma-6 at commit 2664c31 (October 24, 2026), with the original SentencePiece tokenizer (bpe.model). The source files were verified against the repository's checksums (emma6.onnx.data: sha256 da1d8d8d…09e4).

Authorship and rights remain with Egomnia S.p.A., under the license and the original model card.

Available files

emma-6-F32.gguf is the full-precision (F32) GGUF conversion of the original model. The other variants are derived from this file with llama-quantize, using the quantization types supported by llama.cpp.

Available:

emma-6-F32.gguf
emma-6-F16.gguf
emma-6-BF16.gguf
emma-6-Q8_0.gguf
emma-6-Q6_K.gguf
emma-6-Q5_K_M.gguf
emma-6-Q5_K_S.gguf
emma-6-Q5_1.gguf
emma-6-Q5_0.gguf
emma-6-Q4_K_M.gguf
emma-6-Q4_K_S.gguf
emma-6-Q4_1.gguf
emma-6-Q4_0.gguf
emma-6-IQ4_NL.gguf
emma-6-IQ4_XS.gguf
emma-6-Q3_K_L.gguf
emma-6-Q3_K_M.gguf
emma-6-Q3_K_S.gguf
emma-6-IQ3_M.gguf
emma-6-IQ3_S.gguf
emma-6-Q2_K.gguf
emma-6-TQ2_0.gguf — not usable (see below)
emma-6-TQ1_0.gguf — not usable (see below)
emma-6-Q1_0.gguf — not usable (see below)
emma-6-MXFP4_MOE.gguf

Not usable: emma-6-TQ2_0.gguf, emma-6-TQ1_0.gguf, emma-6-Q1_0.gguf. These 1-2 bit formats (the ternary TQ types are designed for models trained with ternary weights) destroy Emma-6: they produce meaningless text. On a reference Italian text their perplexity is above 170,000, against 127.6 for the F32 file. They are published only for completeness. The lowest-precision usable file is emma-6-Q2_K.gguf.

On Emma-6, which has no mixture-of-experts layers, emma-6-MXFP4_MOE.gguf is in practice equivalent to emma-6-Q8_0.gguf (same size and same output quality).

All files were verified to be reproducible from emma-6-F32.gguf with llama.cpp: quantizing again produces byte-identical files, and the SHA-256 of every uploaded file matches the local one.

Running with llama.cpp

The files run on official, unmodified llama.cpp; no custom build or patch is needed (verified with release b12012).

Interactive chat

llama-cli -m emma-6-F32.gguf -c 4096 -ngl 99

Single prompt

llama-cli -m emma-6-F32.gguf -c 4096 -ngl 99 -st -p "Qual è la capitale d'Italia?"

OpenAI-compatible server

llama-server -m emma-6-F32.gguf -c 4096 -ngl 99

The chat template and the sampling parameters are embedded in the file, so no other flag is needed. -ngl 99 loads the layers on the GPU, if available; omit it to use the CPU only. -c 4096 sets the model's maximum context length.

Adaptations compared to the ONNX checkpoint

The weights are converted without loss (F32). For the llama architecture of llama.cpp:

RoPE: the Q and K projections are permuted from the half-split (GPT-NeoX) layout to the interleaved (GPT-J) layout, as for LLaMA models.
Tied embeddings: the ONNX lm_head is bit-identical to the token embedding, so it is not stored twice; llama.cpp reuses token_embd as the output layer.
Chat template: the conversation format is embedded in the file (tokenizer.chat_template); see Prompt format.
Sampling defaults: the official default preset is embedded (general.sampling.*); see Sampling parameters.

Verified against the original ONNX model: logits match within 2.4e-4 (up to 2,601 tokens of context), greedy generation is token-identical, and llama.cpp's sampler reproduces the reference sampling distribution.

Prompt format

The official repository does not publish a chat template. The format below was reconstructed empirically, by testing the candidate formats on the original ONNX model (likelihood of the answers and generation quality), and was later confirmed by Egomnia: the example prompt they published in this discussion tokenizes to exactly the same tokens as this template's output:

<|system|> {system} <|user|> {message} <|assistant|> {answer} <|user|> {message} <|assistant|>

<|system|>, <|user|> and <|assistant|> are dedicated tokens of the original tokenizer. The whole conversation is a single text, without an end-of-sequence token between turns: with this format the prompt token counts match exactly those reported by the official service for the same conversations. The embedded template applies it automatically (llama-cli, llama-server and any client that uses tokenizer.chat_template).

Default system prompt

According to Egomnia's API documentation, the official service adds its own system prompt (about 95 tokens). Egomnia keeps that original prompt reserved, but has published an alternative version for local use, which reproduces some of its main behaviour and configuration instructions (discussion). When you don't send a system message, the template uses this alternative:

Sei Emma-6, l'assistente AI di Egomnia S.p.A.
Regole:
1. Rispondi sempre in italiano.
2. Sii preciso, chiaro e utile.
3. Utilizza Markdown per migliorare la leggibilità delle risposte (titoli, elenchi, grassetti e blocchi di codice).
4. Tieni conto del contesto delle conversazioni precedenti, evitando ripetizioni non necessarie.
5. Quando un'informazione è ambigua o mancante, poni una domanda mirata prima di formulare la risposta.

It is not the system prompt used by the official service, which remains private. You are free to replace it or remove it:

Replace it by sending your own system message: -sys "..." with llama-cli, or a {"role": "system", "content": "..."} message through the OpenAI-compatible API.
Remove it for a single request by sending an empty system message ({"role": "system", "content": ""}), or for every request by starting llama-cli or llama-server with --chat-template-kwargs '{"default_system": ""}'.

In our tests the model answers noticeably worse without any system prompt, so removing it is not recommended unless you supply your own.

Raw prompts. If you build the prompt yourself instead of using the chat template (for example with llama-completion or the /completion endpoint), start it with a space: the file sets tokenizer.ggml.add_space_prefix = false so that chat prompts tokenize exactly like the original tokenizer, and the leading space restores the original tokenization of raw text.

Sampling parameters

The default values are those of the official Emma service: the Bilanciata preset, the default of emma.egomnia.com, as published by its API (GET /api/models) and shown in the chat settings (October 30, 2026). They are embedded in the GGUF, so llama.cpp applies them without any flag:

temperature: 0.7
top-k: 40
top-p: 0.9
repeat-penalty: 1.1
min-p: 0 (disabled)

The other official presets, for use with explicit flags:

Preset	`--temp`	`--top-k`	`--top-p`	`--repeat-penalty`
Focus	0.4	20	0.8	1.1
Bilanciata (default)	0.7	40	0.9	1.1
Creativa	0.9	80	0.95	1.1

Egomnia's inference code is not public, so two details follow the Hugging Face transformers conventions and are an assumption of this conversion: the order of the samplers (repetition penalty, temperature, top-k, top-p) and the repetition penalty being applied to every token of the context, prompt included (repeat-last-n 4096, the whole context).

As in the official API, there is no default limit on the length of the answer: generation stops at the end-of-sequence token or at the context limit. For deterministic output use --temp 0.

The official service also runs components that are not part of the model and are not included here: the Emma Guardrails safety filter, a repetition detector and document retrieval (RAG).

Tokenizer note

The original SentencePiece tokenizer normalizes the text (nmt_nfkc, remove_extra_whitespaces): line breaks, tabs and repeated spaces become a single space. llama.cpp does not apply this normalization, so the embedded template does it on every message, including the most common Unicode substitutions in Italian text (… and the non-breaking space). Chat prompts therefore tokenize exactly like the original. Rarer characters changed by NFKC (for example full-width letters or ligatures) may still tokenize differently.

Because of this normalization the model never saw line breaks: it often separates the parts of an answer with ###, which the official chat displays as line breaks.

llama-server may return replies that start with a space; this comes from llama.cpp's token-by-token decoding and can be trimmed.

Multi-turn note

Emma-6 is used as a chat model: the official chat keeps the conversation history active. In our tests the model handles short conversations: it uses the previous one or two turns to recall a name or a city, or to resolve references ("In che anno è stata completata?" after a question about the Eiffel Tower). It does not reliably keep instructions across turns, it sometimes takes the user's name as its own, and it loses information over long histories. The official chat behaves the same way in the same dialogues.

For the most reliable results keep the history short, or send one complete request at a time.

Information about the original model

The following information comes from the model card of egomnia/emma-6 (version of October 24, 2026, commit 2664c31). Only the heading "Export" was renamed to "Original export"; the rest is unchanged.

Emma-6 is an open-source Italian Large Language Model developed by Egomnia S.p.A.

Emma-6 is an Italian-first, general-purpose conversational language model designed with a focus on Italian language understanding and generation, technological sovereignty, experimentation, and research.

Emma-6 is an experimental model and is not intended to compete with frontier-scale proprietary models. Its primary objective is to contribute to the development of an Italian AI ecosystem and to provide an openly available Italian language model that can be studied, evaluated, and further developed.

Model Details

Model name: Emma-6
Organization: Egomnia S.p.A.
Language: Italian
Architecture: Decoder-only Transformer
Parameters: approximately 1.55 billion
Context length: 4,096 tokens
Vocabulary size: 64,000 tokens
Attention: Grouped Query Attention (GQA)
Normalization: RMSNorm
Activation: SwiGLU
Position encoding: RoPE
Embeddings: Tied input/output embeddings
Dropout: 0
RoPE theta: 500,000

Architecture

Emma-6 uses a decoder-only Transformer architecture with the following configuration:

Component	Configuration
Hidden size	2,048
Transformer layers	32
Attention heads	32
Key/Value heads	8
Head dimension	64
Attention type	Grouped Query Attention
Feed-forward activation	SwiGLU
Feed-forward multiplier	8/3
Context length	4,096
Vocabulary	64,000
Normalization	RMSNorm
Position encoding	RoPE
Embeddings	Tied
Dropout	0

The use of 8 key/value heads with 32 attention heads provides a 4:1 GQA configuration, reducing the memory and computational requirements of attention while retaining multiple query heads.

Tokenizer

Emma-6 uses a SentencePiece BPE tokenizer with byte fallback.

Vocabulary size: 64,000
Tokenizer type: SentencePiece BPE
Byte fallback: enabled
Special token IDs are explicitly defined in the model configuration.

The tokenizer was trained on a large sample of the cleaned Italian pretraining corpus.

Training Data

Emma-6 was pretrained on a large-scale Italian text corpus.

The training pipeline was designed around approximately:

100 GB of raw text
Approximately 25 billion tokens after preprocessing and tokenization

The corpus was processed through a dedicated cleaning pipeline before training.

The preprocessing pipeline includes:

HTML removal
Unicode NFKC normalization
URL removal
Whitespace normalization
Sentence splitting
Exact deduplication
64-bit Blake2b hashing for duplicate detection

The goal of the preprocessing stage was to reduce noise and duplication while preserving useful Italian linguistic content.

Pretraining

Emma-6 was pretrained using autoregressive next-token prediction.

The training configuration includes:

90,000 training steps
Sequence length: 4,096 tokens
bfloat16 training
FSDP ZeRO-2
Gradient checkpointing
Gradient accumulation
Cosine learning-rate schedule
Linear warmup
AdamW-based optimization
Weight decay: 0.1
Gradient clipping
NVIDIA H200 GPUs

The effective training configuration corresponds to approximately 1.57 million tokens per optimization step, with approximately 141.6 billion tokens processed during the complete pretraining schedule.

This corresponds to multiple passes over the approximately 25-billion-token training corpus.

Supervised Fine-Tuning

After pretraining, Emma-6 was further trained using Supervised Fine-Tuning (SFT) on curated prompt/response examples.

The SFT stage is designed to improve:

Instruction following
Conversational behavior
Response quality
Italian-language generation
General usefulness
Compliance with the intended assistant behavior

The SFT pipeline uses loss masking, so the model is primarily optimized on the response portion rather than being trained to reproduce the input prompt.

The training configuration was designed for approximately 120,000 prompt/response examples and multiple training epochs.

Direct Preference Optimization

Following supervised fine-tuning, Emma-6 was further aligned using Direct Preference Optimization (DPO).

The DPO stage uses preference data containing alternative responses to the same prompt, distinguishing preferred responses from rejected responses.

DPO was used to further improve the behavior of the final model, including:

Instruction following
Helpfulness
Response quality
Conversational coherence
Preference alignment
Reduction of undesirable response patterns

The final Emma-6 model therefore incorporates both SFT and DPO alignment stages following large-scale pretraining.

Training Pipeline

The overall Emma-6 training process can be summarized as:

Large-scale Italian corpus
          ↓
Corpus cleaning and deduplication
          ↓
SentencePiece BPE tokenizer
          ↓
Autoregressive pretraining
          ↓
Supervised Fine-Tuning (SFT)
          ↓
Direct Preference Optimization (DPO)
          ↓
Emma-6

Training Infrastructure

The training pipeline was designed for multi-GPU execution and large-scale model training.

Reference hardware includes:

1 × NVIDIA H200 GPUs
141 GB GPU memory per GPU
282 GB total GPU memory
512 GB system RAM
Approximately 1.5 TB NVMe storage
AMD EPYC 9555 64-Core CPU

The training implementation supports Flash Attention where available, with a PyTorch attention fallback.

Original export

Emma-6 can be exported in multiple formats.

The production export includes:

PyTorch model weights
ONNX model
SentencePiece tokenizer
Model configuration
Full training/configuration metadata

The ONNX export uses:

ONNX opset 21
FP32
External Data Format for large model weights

An INT8 dynamically quantized ONNX version can also be produced using ONNX Runtime.

Intended Use

Emma-6 is intended for:

Italian-language research
AI and NLP experimentation
Educational purposes
Model evaluation
Conversational AI experiments
Local and private inference
Development of Italian AI applications

Emma-6 can also be used as a research foundation for applications requiring an Italian-focused language model.

Out-of-Scope Use

Emma-6 is not designed to be used as:

A replacement for professional medical, legal, or financial advice
A fully autonomous decision-making system
A guaranteed factual knowledge source
A safety-critical control system
A system for making high-impact decisions about individuals without appropriate human oversight

Users should independently verify important information generated by the model.

Limitations

As an approximately 1.55B-parameter model, Emma-6 has significantly fewer parameters and computational resources than frontier-scale language models.

Potential limitations include:

Hallucinations
Factual inaccuracies
Limited reasoning capabilities on highly complex tasks
Variable performance on specialized domains
Potentially inconsistent responses
Sensitivity to prompt formulation
Biases inherited from training data
Reduced performance outside Italian compared with models specifically optimized for multilingual use

Emma-6 should therefore be evaluated according to the specific application in which it is deployed.

Privacy and Data Considerations

Users should avoid providing personal, confidential, sensitive, or proprietary information unless the specific deployment environment provides appropriate safeguards.

Organizations deploying Emma-6 should implement appropriate privacy, security, logging, retention, and access-control policies according to their use case and applicable legislation.

Responsible Use

Emma-6 is released as an open-source research and development project.

Users and developers are responsible for ensuring that their use of the model complies with applicable laws, regulations, platform policies, and ethical requirements.

Human oversight should be maintained for applications where incorrect or harmful outputs could have significant consequences.

License

Emma-6 is released under the OpenRAIL license.

Please refer to the license terms distributed with the model before using, modifying, or redistributing the model.

About Egomnia

Emma-6 is developed by Egomnia S.p.A., an Italian technology company working in AI, ICT, software development, cybersecurity, and digital innovation.

Egomnia is developing Emma as part of its broader research and development activities in Italian artificial intelligence and technological sovereignty.

Citation

If you use Emma-6 in research, experimentation, or derivative projects, please cite the project as:

@misc{egomnia_emma6,
  title        = {Emma-6},
  author       = {Egomnia S.p.A.},
  year         = {2026},
  organization = {Egomnia S.p.A.},
  language     = {Italian}
}

Acknowledgements

Emma-6 was developed by the Egomnia S.p.A. team as part of its research and development activities in artificial intelligence.

The project aims to contribute to an open and increasingly independent Italian AI ecosystem.

Downloads last month: 2,009

GGUF

Model size

2B params

Architecture

llama

Hardware compatibility

1-bit

2-bit

3-bit

4-bit

5-bit

6-bit

8-bit

16-bit

32-bit

Model tree for MrMeOrYou/emma-6-GGUF

Base model

egomnia/emma-6

Quantized

(2)

this model

MrMeOrYou
/

emma-6-GGUF

Emma-6 (GGUF)

Preamble

Weights provenance

Available files

Running with llama.cpp

Interactive chat

Single prompt

OpenAI-compatible server

Adaptations compared to the ONNX checkpoint

Prompt format

Default system prompt

Sampling parameters

Tokenizer note

Multi-turn note

Information about the original model

Model Details

Architecture

Tokenizer

Training Data

Pretraining

Supervised Fine-Tuning

Direct Preference Optimization

Training Pipeline

Training Infrastructure

Original export

Intended Use

Out-of-Scope Use

Limitations

Privacy and Data Considerations

Responsible Use

License

About Egomnia

Links

Citation

Acknowledgements

Model tree for MrMeOrYou/emma-6-GGUF