Fidel2.0-1B-GGUF

Fidel 2.0 is a compact competitive coding model from 4E-AI, combining Mamba3 MIMO sequence modeling, attention and a latent mixture of experts. It is designed for programming problems, algorithmic solutions and revision using execution feedback supplied by an application.

This repository provides a lossless GGUF export of Fidel2.0-1B, together with its matching native Linux and Windows backends for Unsloth Studio text/code generation. The original weights, tokenizer, chat formatting and 0.25 numerical blend are preserved.

Use the included Fidel backend. Stock Studio/llama.cpp does not yet execute this custom fidel2 architecture. Install the matching backend once, then select the GGUF in Studio.

Fidel Highlights

• Competitive coding focus: Programming problems, algorithms, data structures and feedback-guided code revision.
• Hybrid architecture: Eight Mamba3 MIMO blocks and one attention block, with two of sixteen routed experts selected per token.
• Lossless export: All 359 persistent tensor payloads retain their original values. Tokenizer metadata and exact position tables are embedded in the GGUF.
• Original numerical recipe: The activation-dependent computation and separate 0.25 blend paths remain part of native execution.
• Hybrid caching: Bounded Mamba state, attention KV and fixed-prompt state support incremental decoding.
• Studio integration: The matching backend passed 27 integration checks covering loading, output, streaming, cancellation and request isolation.

Model Overview

Property	Configuration
Developer	4E-AI
Source model	Fidel2.0-1B
Primary focus	Competitive programming and algorithmic problem solving
Architecture	Mamba3 MIMO, attention and latent MoE
Backbone layers	9: eight Mamba blocks and one attention block
Hidden dimension	1,536
Experts per layer / selected per token	16 / 2
Vocabulary size	131,072
Combined input/output context	8,192 tokens
GGUF precision	Original mixed precision: BF16 and FP32, with exact boolean values represented as I8
GGUF file size	5,396,953,024 bytes, approximately 5.40 GB
Numerical blend	0.25, preserved
Validated runtime platform	Linux x86_64 / Ubuntu 24.04 and native Windows x86_64
Validated GPUs	NVIDIA L4 on Linux; RTX 4050 Laptop GPU on Windows
Model license	Apache-2.0

This is an original mixed-precision GGUF, rather than a static Q4 export. The numerical recipe depends on activations during execution; a generic weight-only quantization does not reproduce it.

Precision Variant and VRAM

Only one weight-storage variant is currently published:

Precision variant	File	Download size	Static weight quantization
Original mixed FP32/BF16 (lossless)	Fidel2.0-1B.gguf	5.40 GB	No additional weight quantization; original values preserved

The custom NVFP4 runtime recipe and 0.25 blend are preserved by the matching backend. This file is not a conventional Q4, Q5 or Q8 GGUF, and no such additional variants are currently provided. The Windows low-VRAM option uses the same GGUF: it streams unchanged weights between blocks rather than reducing their precision.

Runtime preset	Tested GPU capacity	Sampled total GPU memory use	Context scope	Required option
Native Windows, weight streaming	6 GB, RTX 4050 Laptop GPU	3,084 MiB (about 3.0 GiB) during the Windows checks, including desktop/runtime overhead	1,024-token preset	--fidel-low-vram
Linux, resident weights	24 GB, NVIDIA L4	9,380 MiB (about 9.2 GiB) in a short generation probe	Memory figure is from a short probe with a 1,024-token limit; full-context correctness was separately checked through 8,192	Default resident mode

For the tested 6 GB Windows setup, use the low-VRAM flag and start at 1,024 tokens. Weight streaming trades speed for lower VRAM use. These are sampled observations and tested GPU capacities, not guaranteed minimum requirements: context, temporary buffers and other applications can increase memory use. The 5.40 GB download size is not the total VRAM requirement. See setup and validation for the exact presets and measurement scope.

Downloads

File	Contents
Fidel2.0-1B.gguf	Complete lossless model, tokenizer metadata and position tables
Linux backend	Matching Linux launcher, worker, libraries and notices
Windows backend	Native Windows EXE, worker, DLLs and notices
Linux manifest / Windows manifest	File hashes, dependencies and build identities
SHA256SUMS	Download integrity checks
Studio setup	Installation and model settings
Validation	Runtime correctness, measurements and tested scope

Using Unsloth Studio

Install the matching backend once, then select the GGUF with its original chat template, F32 KV cache and one sequence.

Native Windows: Use fidel-llama-server.exe. The 6 GB RTX 4050 was validated with --fit off --fidel-low-vram and a 1,024-token context. Weight streaming reloads the original weight bytes between blocks, reducing VRAM use while retaining CUDA computation and exact numerical behavior. It trades generation speed for lower memory use.

Linux: Use fidel-llama-server. The resident-weight backend was validated on a 24 GB L4, including full native context through 8,192 tokens. WSL2 is a Linux deployment route, but was not separately tested.

Follow the platform-specific setup guide for commands and presets. CPU, AMD and Apple forward backends are not included. Other CUDA GPU families have not yet been admitted for this new backend.

Speculative Decoding

Greedy prompt-lookup speculation is implemented with target verification and complete hybrid-state rollback. It passed 94 exact correctness checks. It is optional and off by default, because it was slower on the two short code probes. Stochastic speculation and trained draft/MTP/EAGLE heads are not included.

Validation Scope

Both published backends passed 180 exact model-frontier comparisons, cache/generation and actual Studio integration checks. Full-context validation covered 8,192 tokens on Linux and the 1,024-token Windows preset; Windows speculative prefix checks also reached 1,028 tokens. These establish implementation fidelity; they are not competitive-programming benchmark scores.

Short warmed L4 measurements showed 7.64–7.86 decode tokens/s, compared with 0.77–0.79 for the earlier correct guarded-history reference. The test used short prompts and seven timed decode calls per trial. Full 8,187-token prefill took 164.124 seconds. These resident-mode Linux timings do not describe Windows weight streaming. See validation for the measurement scope.

License

The model weights and original Fidel code are licensed under Apache-2.0. Third-party components bundled with the backend retain their respective licenses and attribution; see NOTICE and the archive's licenses/ directory.