# Ein Modell, ein Fork: NInfer gegen Infernix

> Qwen 3.8 27B, NVFP4, DFlash2 — einmal auf NInfer, einmal auf dem Infernix-Fork. Gleiche Hardware, gleiches Modell, gleiche Strategie. Im Dekodieren auf Augenhöhe, im Long-Context-Prefill rund 1,8× schneller bei Infernix. Beide Engines: 12 von 12 versteckten Paaren gefunden.

_Kicker: fork-bench · Datum: 2026-10-09 · Lesezeit: 9 min_

Dasselbe 27-Billionen-Parameter-Modell, NVFP4-quantisiert, dieselbe RTX 5090, derselbe DFlash2-Spekulationslauf — nur die Engine wechselt. NInfer ist der Original-Zweig; Infernix der Fork, der seit September eigene Pfade einschlägt: Hybrid-Prefix-Cache, n-gram copy drafting, Flash-Next-Expert-Offloading. Die Frage: Was hat der Fork aus dem 27B herausgeholt, und wo verliert er? Antwort vorweg: im Dekodieren ist es ein Gleichstand, im Long-Context-Prefill dreht Infernix das Spiel — und in 256K Kontext findet jede Engine alle versteckten Schlüssel-Wert-Paare, ohne eines zu verlieren.

## Setup

### Modell & Gewichte

**swift-1.5-qwen3.8-27b-orcarouter · NVFP4**

Dasselbe Modell in beiden Läufen, dieselbe NVFP4-Quantisierung, dieselbe RTX 5090 (32 GB VRAM). Kein Engine- oder Quantisierungs-Unterschied — isoliert bleibt nur die Engine selbst.

### Engine A — NInfer

**C++/CUDA · DFlash2 · nvfp4-KV**

Die Original-Inferenz-Engine (Neroued/ninfer). QUASAR-NVFP4-Gewichte, nvfp4-KV-Cache, DFlash2-Spekulation. Bewusst `max-concurrency 1`: ein Request nach dem anderen.

### Engine B — Infernix (Fork)

**C++/CUDA · DFlash2 · nvfp4-KV · Hybrid-Prefix-Cache**

Fork von NInfer (Wallawalla47/Infernix), der NInfer-Artefakt `.ninfer` liest. Zusätzliche Pfade: Hybrid-Prefix-Cache (GPU/RAM/Datei), n-gram copy drafting, DFlash2 tree verification. Dieselben Flags, dieselbe Kontextlänge.

### Umfang

**4 × 200 Fragen + 2 × 12 Long-Context**

Ein Lauf pro Engine — ein Indikator, kein statistischer Paper-Claim. Long-Context (RULER, MRCR) als eigener Abschnitt mit 12 Fragen je Benchmark, beide bei 256K Kontext (apples-to-apples).

## Ergebnisse

### NInfer

_NInfer, nvfp4-KV-Cache, DFlash2-Spekulation, C++/CUDA-Engine auf RTX 5090_

Gestartet: 2026-10-05 20:07 UTC

| Benchmark | Genauigkeit | Correct/Total | Decode (tok/s) | Prefill (tok/s) | TTFT (ms) | Output-Tokens | Wall-Time (s) |
|---|---|---|---|---|---|---|---|
| GSM8K | 98.0 % | 196/200 | 331.0 | 2477.2 | 57 | 74055 | 251.3 |
| ARC-Challenge | 93.0 % | 186/200 | 287.0 | 2766.0 | 47 | 35558 | 146.8 |
| MMLU | 89.5 % | 179/200 | 278.7 | 2719.6 | 50 | 102187 | 405.6 |
| GPQA | 77.0 % | 154/200 | 247.7 | 3874.4 | 64 | 538158 | 2245.3 |

#### Long-Context (256K)

| Benchmark | Kontext (K) | Genauigkeit | Correct/Total | Decode (tok/s) | TTFT (ms) | Wall-Time (s) |
|---|---|---|---|---|---|---|
| RULER | 256 | 100.0 % | 12/12 | 297.3 | 56430 | 686.6 |
| MRCR | 256 | 100.0 % | 12/12 | 280.9 | 56584 | 690.0 |

### Infernix

_Infernix-Fork, nvfp4-KV-Cache, DFlash2-Spekulation, Hybrid-Prefix-Cache, C++/CUDA auf RTX 5090_

Gestartet: 2026-10-09 20:56 UTC

| Benchmark | Genauigkeit | Correct/Total | Decode (tok/s) | Prefill (tok/s) | TTFT (ms) | Output-Tokens | Wall-Time (s) |
|---|---|---|---|---|---|---|---|
| GSM8K | 96.5 % | 193/200 | 328.5 | 3054.1 | 48 | 74427 | 257.0 |
| ARC-Challenge | 92.0 % | 184/200 | 277.6 | 2654.0 | 50 | 36146 | 156.1 |
| MMLU | 90.0 % | 180/200 | 276.3 | 2855.7 | 47 | 88777 | 364.1 |
| GPQA | 78.5 % | 157/200 | 245.5 | 4104.8 | 61 | 516855 | 2182.1 |

#### Long-Context (256K)

| Benchmark | Kontext (K) | Genauigkeit | Correct/Total | Decode (tok/s) | TTFT (ms) | Wall-Time (s) |
|---|---|---|---|---|---|---|
| RULER | 256 | 100.0 % | 12/12 | 276.9 | 30675 | 385.1 |
| MRCR | 256 | 100.0 % | 12/12 | 251.6 | 31564.5 | 398.1 |

## Findings

### Decode: ein Gleichstand — der Fork verliert nichts

NInfer hält 247–331 Token/s, Infernix 245–329 Token/s. Der Abstand ist minimal: bei GSM8K 0,8 %, bei MMLU 0,9 %, bei GPQA 0,9 %, bei ARC 3,3 %. Im Long-Context wird es etwas deutlicher: RULER 6,8 %, MRCR 10,4 % zugunsten von NInfer. Das ist der Bereich, in dem der Fork nicht gewinnt — aber auch nicht verliert. Beide Engines streamen mit rund 250–330 Token/s, und wer lokal Antworttexte liest, spürt diesen Unterschied nicht.

### Long-Context-Prefill: der Fork dreht das Spiel

Hier trennt sich der Fork: Für 256K Kontext braucht Infernix 30,7–31,6 s TTFT, NInfer 56,4–56,6 s. Das ist ein Faktor 1,79–1,84 zugunsten von Infernix. Der Grund liegt im Hybrid-Prefix-Cache: Infernix cached KV-Blöcke nach Content in 64-Token-Blöcken und hält Rekursiv-Zustands-Snapshots in drei Ebenen (GPU, Host-RAM, Datei). Wenn ein Prompt Anteile eines bereits gesehenen Kontexts enthält, werden diese nicht neu geprefillt, sondern aus dem Cache bedient. Bei den Long-Context-Benchmarks (RULER, MRCR) mit ihren wiederkehrenden Schlüssel-Wert-Paaren trifft der Cache zu, und der Prefill-Timestamp fällt von 56 s auf 31 s.

### Genauigkeit: praktisch identisch, ±1,5 Prozentpunkte

NInfer führt bei GSM8K (98,0 statt 96,5) und ARC-Challenge (93,0 statt 92,0); Infernix führt bei MMLU (90,0 statt 89,5) und GPQA (78,5 statt 77,0). Der Durchschnitt liegt bei 89,38 % (NInfer) zu 89,25 % (Infernix) — ein Abstand von 0,13 Prozentpunkten, der statistisch nicht belastbar ist. Beide Engines erzeugen mit DFlash2-Spekulation dieselben Antworten; die Engine ändert die Dekodiergeschwindigkeit, nicht die Ausgabe. Die einzelnen Abweichungen sind Lauf-zu-Lauf-Varianz, kein Engine-Effekt.

### Long-Context: beide bei 12 von 12 — keine Nadel verloren

RULER (verstreute Schlüssel-Wert-Paare) und MRCR (2/4/8 Nadeln unter Ablenk-Einträgen) liegen bei beiden Engines exakt auf 100 Prozent (12/12). Qwen 3.8 27B sortiert 256K Kontext-Tokens, ohne zu halluzinieren und ohne „Lost in the middle". Der Fork verliert keine Nadel — und gewinnt keine. Das ist das erwartete Ergebnis: Die Engine ändert, wie schnell das Modell antwortet, nicht was es antwortet.

### Gesamtdauer: Infernix schneller im Long-Context, NInfer im Standard

Der Standard-Vierer-Satz lief bei NInfer in 50,8 Minuten, bei Infernix in 49,3 — bei 750.000 respektive 716.000 Output-Tokens. Infernix schrieb weniger (MMLU: 88.777 statt 102.187; GPQA: 516.855 statt 538.158 Output-Token) und war entsprechend schneller. Im Long-Context dreht sich das Bild: Infernix 385/398 s, NInfer 687/690 s — rund 43 % kürzer. Der Prefill-Vorteil des Hybrid-Prefix-Caches dominiert hier die Dekodier-Geschwindigkeit.

### Ausblick: Flash-Next und Jev-Modus

Der Fork bringt zwei Fähigkeiten mit, die NInfer nicht hat. Erstens: Qwen3.8-Flash-Next (24.576 routed Experts, 63 GiB NVFP4) auf einer RTX 5090 (32 GB) — Infernix hält die Experts in pinned host RAM, cached die Hot-Experts in VRAM und rechnet Cache-Misses auf dem CPU-Teil. NInfer ist auf ein resident Model pro GPU ausgelegt; 63 GiB passen nicht in 32 GB. Zweitens: der Jev-Modus (`POST /v1/decide`, Wire-Shape `POST /v1/systemone`), der typisierte Entscheidungen beantwortet, indem er die Next-Token-Verteilung liest — ohne Generierung. 0,934 Balanced Accuracy über 144 Decisions auf dem 27B. Ein Modell, das Klassifizierung, Scoring und Auswahl als einen Prefill-Kostpunkt beantwortet, ist ein anderer Arbeitsbereich als generativer Text.

## Grenzen

- Ein Lauf mit je 200 Fragen pro Standard-Benchmark — kein Konfidenzintervall, keine Mehrfachwiederholung.
- Long-Context (RULER, MRCR): je 12 Fragen bei 256K Kontext — die 12/12 ist statistisch schwach belastbar, aber konsistent.
- Die beiden Läufe wurden zu unterschiedlichen Zeitpunkten durchgeführt (NInfer: 05.10., Infernix: 09.10. 2026); Systembedingungen (RAM-Nutzung, Hintergrundprozesse) sind nicht garantiert identisch.
- Infernix nutzt einen Hybrid-Prefix-Cache, der bei wiederkehrenden Prompt-Anteilen Treffer liefert; bei völlig neuen Prompts ist der Vorteil unklar. Die Long-Context-Benchmarks enthalten wiederkehrende Schlüssel-Wert-Paare, die den Cache triggern — der Prefill-Vorteil ist damit nicht generalisierbar.
- Der Decode-Vergleich isoliert die Engine nicht vollständig: Infernix nutzt zusätzlich n-gram copy drafting und DFlash2 tree verification neben DFlash2; der genaue Split zwischen „Engine-Architektur" und „zusätzliche Dekodier-Pfade" lässt sich in diesem Design nicht trennen.

## Quellen

- [AI-Benchmark (Läufe vom 05. und 09.10.2026)](https://richard.koehls.de/benchmark/)
- [NInfer (Original-Engine, Neroued/ninfer)](https://github.com/Neroued/ninfer)
- [Infernix (Fork, Wallawalla47/Infernix)](https://github.com/Wallawalla47/Infernix)