---
type: "BlogPosting"
title: "Qwen 3.8 27B Hardware-Guide: Von der RTX 3090 bis zum DGX Spark"
description: "Qwen3.8-27B läuft auf erstaunlich viel Hardware – aber wie schnell wirklich? Baseline- vs. Community-getunte Benchmarks (Stand 19.08.2026): RTX 3090 mit ~1.000 tok/s bei 64 parallelen Streams, RTX 5090 mit 148 tok/s, DGX Spark mit 210 tok/s aggregiert, DFlash 2 mit 3,4x auf der H200 – dazu RTX 5080 Laptop, Mac mini, MacBook Pro, Mac Studio und AMD Strix Halo mit Prefill, Decode und Concurrency."
resource: "https://www.contextstudios.ai/de/blog/qwen-3-8-27b-hardware-guide"
language: "de"
tags: ["AI", "Local LLM", "Hardware", "Qwen", "Benchmarks"]
generated:
  by: "process:contextstudios-md/1"
  at: "2026-10-05T05:52:31.640Z"
status: "stable"
---

# Qwen 3.8 27B Hardware-Guide: Von der RTX 3090 bis zum DGX Spark

Published: 2026-08-19
Tags: AI, Local LLM, Hardware, Qwen, Benchmarks

![Qwen 3.8 27B Hardware-Guide: Von der RTX 3090 bis zum DGX Spark](https://wary-platypus-754.convex.cloud/api/storage/3c0ded64-1517-470c-a615-0636ece2a365)

# Qwen 3.8 27B Hardware-Guide: Von der RTX 3090 bis zum DGX Spark

Am 14. August 2026 hat Alibabas Qwen-Team die Gewichte von **Qwen3.8-27B** unter Apache 2.0 auf Hugging Face veröffentlicht – und damit das aktuell spannendste lokale Modell der 27B-Klasse. Ein dichtes, nativ multimodales Vision-Language-Modell (Text, Bild, Video) mit 262.144 Token nativem Kontext (erweiterbar auf 1M via YaRN), integriertem Multi-Token-Prediction-Head (MTP) und einem Artificial-Analysis-Score von 52 – auf dem Agentic Index liegt es damit vor deutlich größeren Frontier-Modellen. Auf X brachte es Entwickler Sero (@0xSero) auf den Punkt: Ein Modell, das auf ~3.000 $ Hardware läuft, schlägt plötzlich alles, was vor vier Monaten State of the Art war.

Die entscheidende Frage für alle, die das Modell selbst hosten wollen: **Auf welcher Hardware läuft das Ding – und wie schnell?** Die ehrliche Antwort hat zwei Ebenen. Die Baseline-Benchmarks vom Release-Wochenende (llama.cpp ohne Tuning) und das, was die Community in nur fünf Tagen daraus gemacht hat. Der Unterschied liegt je nach Plattform bei **Faktor 2 bis 8**. Wir haben beides zusammengetragen: Hardware-Corner-Messreihen, Simon Willisons Tests, GitHub-Repos von Mia AI Lab, r0b0tlab und syv-ai, Hugging-Face-Diskussionen, den DFlash-2-Release von z-lab/Inco AI und X-Posts aus den ersten Tagen.

> ⚡ **Stand: 19. August 2026.** Dieses Ökosystem bewegt sich täglich – alle Zahlen sind Momentaufnahmen mit Quellenangabe.

## Das Modell in 60 Sekunden

- **27,8 Mrd. Parameter, dense** – kein Mixture-of-Experts. Jeder generierte Token durchläuft das komplette Netz. Das macht die **Speicherbandbreite** zum entscheidenden Faktor – und **spekulatives Decoding zum größten Hebel**, weil es mehrere Token pro Forward-Pass verifiziert.
- **Architektur:** 64 Layer, davon 48 Gated-DeltaNet- und 16 Full-Attention-Layer, plus trainierter MTP-Head direkt im Checkpoint.
- **Multimodal:** Bild- und Videoverständnis nativ (GGUF-Nutzer brauchen zusätzlich den ~0,93 GB großen Vision-Projektor).
- **Reasoning-Modi:** `xhigh` (Default!), `medium`, `low`. Der Default denkt exzessiv – Simon Willison brauchte damit 21 Minuten für einen SVG-Prompt, ohne Reasoning gut 2 Minuten. Für lokale Hardware: `low` oder `medium`.

## Speicherbedarf: die eigentliche Eintrittskarte

Der volle BF16-Checkpoint wiegt ~56 GB. Erst Quantisierung macht daraus ein Consumer-Modell:

| Format | Dateigröße | Realistischer Speicherbedarf |
|---|---|---|
| UD-Q2_K_XL (2-Bit) | 10,7 GB | 16–24 GB |
| UD-Q3_K_XL (3-Bit) | 13,4 GB | 24 GB |
| Q4_K_M (Standard-4-Bit) | 17,1 GB | 24–32 GB |
| UD-Q4_K_XL (Dynamic 4-Bit) | 17,9 GB | 24–32 GB |
| Q6_K | 22,9 GB | 32–48 GB |
| Q8_0 | 29,1 GB | 48–64 GB |
| NVFP4 (nur Blackwell) | ~16,5 GB | 24–32 GB VRAM |
| BF16 | ~56 GB | ab 64 GB |

Dazu kommt der **KV-Cache**: Hardware Corner hat mit einem Q4-Build **18 GB bei 4k**, 22 GB bei 64k, 26 GB bei 128k und 34 GB bei 256k Kontext gemessen. Die Community hat diese Grenzen aber bereits verschoben – mit FP8-KV-Cache (halber Bedarf), quantisierten Embeddings (2,6 GB gespart, dazu unten mehr) und KV-Quantisierung in llama.cpp. Faustregel trotzdem:

> **24 GB VRAM = 64k Kontext out of the box. 32 GB = 128k. Volle 262k gehen auf 24 GB nur mit Tuning – oder mit Unified Memory.**

---

## 1. Klassischer Desktop-PC mit GPU (RTX 3090 / 4090 / 5090)

### Baseline: llama.cpp, Q4, MTP deaktiviert (Hardware Corner)

| Kontext | RTX 3090 (24 GB) – Prefill / Decode | RTX 4090 (24 GB) – Prefill / Decode | RTX 5090 (32 GB) – Prefill / Decode |
|---|---|---|---|
| 4k | 1.308 / 40,3 t/s | 2.963 / 46,2 t/s | 3.750 / 74,8 t/s |
| 32k | 977 / 37,0 t/s | 2.367 / 42,2 t/s | 1.146 / 29,0 t/s |
| 64k | 767 / 34,0 t/s | 1.918 / 38,4 t/s | 718 / 26,2 t/s |
| 128k | – (VRAM-Limit) | – (VRAM-Limit) | 461 / 22,8 t/s |

Das ist der Stand, wenn man einfach nur `llama-server` startet. Solide – aber weit unter dem, was die Hardware kann.

### Was die Community daraus gemacht hat (Stand 19.08.)

**RTX 3090 – der Star der Woche.** Das Repo `syv-ai/qwen38-27b-rtx3090` zeigt, was mit einem getunten vLLM-Stack auf einer einzelnen, sogar auf 250 W gedrosselten 3090 geht: **~114 t/s Single-User** bei Default-Sampling (118–124 t/s greedy) mit 64k Kontext, noch **95–100 t/s bei 150k Kontext** – und im Batch-Betrieb **~1.000 t/s aggregiert bei 64 parallelen Requests**. Die Zutaten: int8-Tensor-Core-GEMMs, MTP-Drafts mit reduziertem Draft-Vokabular, kalibrierter int4-LM-Head und ein Trick, der 2,6 GB VRAM freischaufelt: Qwen3.8 hat ungebundene Embeddings, und die öffentlichen W4A16-Quants schleppen zwei unquantisierte 2,5-GB-BF16-Matrizen mit – das Repo requantisiert beide auf int8 ohne messbaren Qualitätsverlust.

**RTX 5090.** Ein japanischer Entwickler (note.com) hatte das Modell rund eine Stunde nach Release im täglichen Setup und misst mit abgestimmtem Speculative Decoding **148,3 t/s bei Code** und 128,6 t/s bei japanischem Fließtext. Eine Hugging-Face-Diskussion meldet mit Q6-Quant plus MTP 98 t/s, und das SGLang-Team **200+ t/s mit NVFP4 + Speculative Decoding**. Die KGP-Talkie-Messreihe (45 Konfigurationen) bestätigt den Mechanismus: `--spec-type draft-mtp` bei Draft-Tiefe 3 = **Faktor 1,81 gratis**, verlustfrei, da spekulative Tokens verifiziert werden.

**Der 24-GB-Blackwell-Beweis.** Auf einer RTX PRO 4000 (24 GB) läuft das Modell mit gepinnten llama.cpp-Patches bei **50,4 t/s im Produktionsschnitt – mit vollen 256k Kontext**. Embedded MTP hob dort den Durchsatz von 21,2 auf 59,5 t/s (2,81x); der Custom-Build brachte gegenüber Clean Master weitere +22 %.

**Einordnung neu:** Die 3090 ist nicht mehr nur der Sparfuchs-Tipp – mit dem richtigen Stack ist sie ein vollwertiger Serving-Node. Die 4090 profitiert von denselben Hebeln. Die 5090 bleibt die schnellste Single-GPU, aber der Abstand schrumpft, sobald überall Speculation läuft.

---

## 2. Laptop mit GPU: der RTX-5080-Fall (16 GB)

Hier bleibt es unbequem, aus einem einzigen Grund: **Die RTX 5080 Laptop GPU hat 16 GB VRAM – das kleinste brauchbare 4-Bit-File ist 17,1 GB groß.** Q4 passt nicht vollständig auf die Karte. Drei realistische Optionen:

1. **UD-Q3_K_XL (13,4 GB) komplett im VRAM.** Läuft sauber mit 8–16k Kontext und profitiert von den ~896 GB/s der Karte. Belastbare Messwerte für exakt diese Kombination fehlen weiterhin; die Bandbreiten-Arithmetik legt Decode-Raten in der Liga der Desktop-24-GB-Baseline nahe – mit dem Qualitätsverlust eines 3-Bit-Quants.
2. **Q4 mit Partial Offload ins System-RAM.** Eine Geduldsprobe: Der Referenz-Test auf einer RTX 5070 Ti Laptop (12 GB) lieferte **3,3–4,5 t/s Decode und 20–27 t/s Prefill**. Auf 16 GB fällt der Offload-Anteil kleiner aus, das Muster bleibt: Sobald Gewichte im System-RAM liegen, bricht die Geschwindigkeit auf einstellige Werte ein.
3. **NVFP4 (~16,5 GB Weights)** ist auf 16 GB ebenfalls zu knapp, sobald KV-Cache und Runtime dazukommen.

**Fazit für Laptops:** 16 GB ist für dieses Modell die unglückliche Mitte. Wer einen Laptop gezielt dafür kauft, greift zur **RTX 5090 Laptop GPU (24 GB)** – dort laufen Q4/Q5 vollständig im VRAM, und die Desktop-Tuning-Rezepte (MTP, DFlash 2) übertragen sich, gedrosselt durch Power-Limits und Kühlung. Auf der 5080 bleibt das Modell ein Experiment, kein Daily Driver.

---

## 3. Mac mini (M4 / M4 Pro)

Apple Silicon dreht die Logik um: Statt eines harten VRAM-Limits gibt es Unified Memory, das der GPU fast vollständig zur Verfügung steht. Der Preis dafür ist Bandbreite.

| Konfiguration | Bandbreite | Was läuft | Einschätzung |
|---|---|---|---|
| M4, 16 GB | 120 GB/s | nur 2-Bit, kurzer Kontext | Experiment, keine Kaufempfehlung |
| M4, 24–32 GB | 120 GB/s | Q3/Q4 | läuft, aber langsam (einstellige t/s realistisch) |
| M4 Pro, 48 GB | 273 GB/s | Q4 bis Q8 mit Headroom | **bester Preis-Leistungs-Mac** |
| M4 Pro, 64 GB | 273 GB/s | Q8 + Vision + großer Kontext | komfortabel |

Referenzpunkt für die untere Grenze: Ein M2 Pro mit 16 GB schaffte mit dem 2-Bit-Quant gemessene 7,1 t/s – bei 4-Bit scheiterte dieselbe Maschine komplett. Erst der **M4 Pro mit 2,3-facher Bandbreite** macht den Mac mini zum ernsthaften Qwen-Host. Wichtig für alle Macs: **MLX statt GGUF nutzen** (Details im MacBook-Abschnitt) – das bringt auf M5-Chips rund 40 % mehr Decode.

---

## 4. MacBook Pro (M4 Pro / M4 Max / M5 Pro / M5 Max)

### Baseline: llama.cpp/LM Studio auf M5 Max (128 GB)

| Kontext | Prefill (t/s) | Decode (t/s) |
|---|---|---|
| 4k | 834 | 31,4 |
| 16k | 544 | 23,6 |
| 32k | 517 | 21,6 |
| 64k | 425 | 18,2 |

Simon Willison bestätigt die Größenordnung aus der Praxis: 15–30 t/s in LM Studio – genug für Chat, Coding-Agents (getestet mit Pi) und Vision-Aufgaben, aber spürbar langsamer als APIs.

### Der MLX-Sprung

Die MLX-Community hat nachgelegt: Eine gemessene MLX-Konvertierung erreicht auf dem **M5 Max mit 4-Bit ~33 t/s bei nur 15,5 GB Peak-Memory** (8-Bit: ~18 t/s bei 28,9 GB, BF16: ~10 t/s bei 54 GB). Auf dem **M5 Pro** dokumentiert ein Deployment-Test **+40 % gegenüber GGUF: von ~28 auf ~40 t/s** – die Neural Accelerators der M5-GPU zahlen sich hier direkt aus. Zwei Caveats: Die reine `mlx-lm`-Konvertierung ist **text-only** (Vision-Encoder und MTP-Drafter werden entfernt); wer Bilder braucht, nimmt die `mlx-vlm`-Builds der mlx-community. Und seit dem 18.08. gibt es Speculative Decoding auch auf dem Mac: Der **oMLX-Build mit DFlash-2-Support** läuft laut Inco-Demo auf dem M5 Max mit dem 4-Bit-MLX-Modell plus DFlash-2-Drafter – damit rücken auch auf Apple Silicon Werte deutlich jenseits der 40 t/s in Reichweite.

**Einordnung der Varianten:** Ein MacBook Pro mit M4 Pro (24–48 GB) verhält sich wie der Mac mini M4 Pro. M4 Max / M5 Max ab 36–48 GB ist die komfortable Apple-Laptop-Wahl. Der große Vorteil gegenüber jedem Windows-Laptop bleibt: 64–128 GB Unified Memory erlauben Q8, Vision und lange Kontexte gleichzeitig – lautlos und im Akku.

---

## 5. Mac Studio (M4 Max / M3 Ultra)

| Konfiguration | Bandbreite | Einschätzung |
|---|---|---|
| M4 Max, 36 GB | 410 GB/s | schnelles Q4/Q5; Q8 wird eng |
| M4 Max (40-Core-GPU), 64 GB | 546 GB/s | **Sweet Spot**: Q8, Vision, langer Kontext, Platz für andere Apps |
| M3 Ultra, 96 GB+ | 819 GB/s | schnellster Mac-Decode, sogar BF16 möglich – Overkill für ein einzelnes 27B |

Der Mac Studio ist der leise Workstation-Pfad. Mit 546 GB/s liegt der M4 Max deutlich über dem MacBook-Niveau, entsprechend höher fallen die Decode-Raten aus – Richtung RTX-3090-Baseline, ohne Lüfterlärm. Auch hier gilt: MLX-Builds nutzen, und mit oMLX + DFlash 2 kommt Speculation dazu. Der **M3 Ultra** verdoppelt die Bandbreite nahezu; für Qwen 3.8 27B allein wirtschaftlich schwer zu rechtfertigen, interessant, wenn zusätzlich 70B+-Modelle auf derselben Maschine laufen sollen.

---

## 6. NVIDIA DGX Spark (GB10): vom Sorgenkind zum Serving-Node

Der Spark ist das beste Beispiel dafür, wie schnell sich das Bild in fünf Tagen gedreht hat.

### Baseline: llama.cpp, Q4 (Hardware Corner, Dell Pro Max GB10)

| Kontext | Prefill (t/s) | Decode (t/s) |
|---|---|---|
| 4k | 813 | 12,2 |
| 64k | 576 | 9,7 |
| 128k | 442 | 8,0 |
| 256k | 228 | 5,9 |

Mit 273 GB/s LPDDR5x-Bandbreite ist das dichte 27B im Stock-llama.cpp zäh – Simon Willison kam mit LM Studio auf 15–30 t/s und holte mit `--spec-type draft-mtp` bereits +72 %.

### Community-Stand 19.08.: SGLang + NVFP4 + Speculation

**Mia AI Lab** (`MiaAI-Lab/Qwen3.8-27B-SGLang-DGX-Spark`) hat aus dem Spark einen echten Server gemacht: **~33–35 t/s Single-Stream mit MTP** und **~195–210 t/s aggregiert bei 10 parallelen Streams** – bei bis zu **1M Kontext via YaRN, ohne Geschwindigkeitsunterschied zwischen 256k und 1M**. Dazu kamen handfeste Systemfixes: Der GB10 versteckt 10 schnelle und 10 langsame CPU-Kerne – das Pinning des Servers auf die schnellen brachte +5 %, ein Fix einer doppelten Speicherreservierung im GDN-State-Pool weitere Reserven. Das Schwester-Repo liefert das vLLM-Pendant mit Unsloth-NVFP4, FP8-KV-Cache und MTP.

**r0b0tlab** (`qwen38-27b-nvfp4-sm121-sglang`) liefert die dazu passenden, sauber gematchten Evals auf dem Spark (NVFP4, think-off): **DFlash 2 als Produktions-Sieger mit 28,4 t/s Single-Stream** und einer Concurrency-Leiter von 23,5 (c1) über 55,0 (c4) bis **92,1 t/s bei c8** – die EAGLE/MTP-Variante erreicht bei c8 sogar **123,9 t/s**. Auf dem realen 200-Task-Qualitätsset lag DFlash 2 End-to-End bei im Mittel 47,5 t/s, +40 % gegenüber dem vorherigen DSpark-Setup, bei identischen GSM8K-/HumanEval-/IFEval-Scores.

**Neues Fazit Spark:** kein Speed-Krüppel mehr, sondern ein leiser 128-GB-Serving-Node für kleine Teams – einzigartig ist weiterhin, dass 256k–1M Kontext hier einfach *passen*.

---

## 7. AMD Strix Halo (Ryzen AI Max+ 395)

Strix Halo (Radeon 8060S, bis 128 GB LPDDR5X, 256 GB/s) ist die x86-Antwort auf Apples Unified Memory – mit einer sehr aktiven Tuning-Community:

| Setup | Decode (t/s) | Quelle |
|---|---|---|
| Launch-Day, Q5 / Q8, untuned | 10,5 / 7,5 | Reddit r/StrixHalo |
| Q4_K_M Baseline vs. getuntes MTP | 10,7 → **30,3** (Faktor 2,83) | Hugging Face (kingjones777) |
| AMD offiziell, llama.cpp Vulkan, MTP=4 | bis 24,5 | AMD-Blog (Day-0) |
| ROCmFP4-Community-Build + MTP | 30,6–36,0 | GitHub (julianmb/q38rocm) |
| Speculation-Stack (MTP n12 + ngram), 96k ctx | 59,7–64 cold / **11–24 im realen Chat** | GitHub (KyaniteLabs) |

Die wichtigsten Erkenntnisse:

- **MTP ist auf Strix Halo der größte Einzelhebel** – bis Faktor 2,83. Aber: llama.cpps Default-Draft-Tiefe von 16 halbiert den Durchsatz; das Optimum liegt bei **3–4**.
- **Backend-Split:** ROCm liefert ab 16k das bessere Prefill (~330 vs. ~267 t/s), Vulkan das bessere Decode.
- **Prefill ist die Achillesferse:** Ein 32k-Prompt braucht rund zwei Minuten bis zum ersten Token.
- **Vorsicht bei Rekordwerten:** Die 60-t/s-Angaben sind Cold-Start-Bestwerte; n-gram-Speculation kann Benchmarks zusätzlich verfälschen, weil wiederholte Prompts den Cache trainieren – ein Tester sah so scheinbare ~180 t/s, wo real ~47 anlagen. **Realistisch sind 11–24 t/s im echten Chat** – nach Tuning also MacBook-Niveau, bei 128 GB Speicher und deutlich niedrigerem Preis. Ein DFlash-2-Pfad für ROCm zeichnet sich ab (der llama.cpp-PR ist backend-agnostisch), gemessene Strix-Zahlen dafür stehen noch aus.

---

## Speed-Tuning: die vier Hebel, die überall wirken

1. **`reasoning_effort` runterdrehen.** Der Default `xhigh` ist auf Consumer-Hardware unbrauchbar. Messung: Reasoning aus = 10x schneller zur sichtbaren Antwort, `medium` kostet fast nichts. Selbst der freie HF-Community-Endpoint hat den Default inzwischen auf `medium` gestellt.
2. **DFlash 2 (neu, 18.08.) – der neue Spitzenhebel.** Der Block-Diffusion-Drafter von z-lab/Inco AI (`z-lab/Qwen3.8-27B-DFlash2`, Spiegel von `incoai/…`) ist ein eigenes 2B-Draft-Modell (~4 GB), das ganze Token-Blöcke parallel entwirft; ein leichtgewichtiger Selector wählt den kohärenten Pfad, das Zielmodell verifiziert – **Output nachweislich identisch** (Rejection Sampling). Die Model-Card-Messung auf einer H200 (SGLang, Block 8): Single-Stream von 69 t/s autoregressiv auf **184–236 t/s je nach Task (2,67–3,43x)** – der native MTP-Head schafft dort 135–179 t/s. Mittlere Akzeptanzlänge: 4,80 Tokens pro Verify vs. 4,28 bei MTP. Verfügbar in SGLang (PR #35371, gemerged 19.08.), vLLM, llama.cpp (`--spec-type draft-dflash`) und via oMLX auf Apple Silicon.
3. **MTP aktivieren**, wenn kein DFlash-2-Drafter greifbar ist (`--spec-type draft-mtp`, Draft-Tiefe 3–4): +72 % auf dem Spark, +81 % auf der 5090, +183 % auf Strix Halo. Der Head steckt bereits im GGUF (Layer 64) – kein zweiter Download nötig.
4. **Speicher freiräumen:** KV-Cache quantisieren (q8_0/q4_0 bzw. FP8 in vLLM/SGLang – halber KV-Bedarf) und bei W4A16-Quants die beiden unquantisierten 2,5-GB-Embedding-Matrizen auf int8 requantisieren (**2,6 GB VRAM zurück**, keine messbare Qualitätseinbuße). Genau diese Kombination bringt 150k–262k Kontext auf 24-GB-Karten.

## Concurrency: vom Einzelplatz zum Serving – jetzt mit echten Zahlen

Weil Qwen 3.8 27B dense ist, liest jeder Token alle 27B Parameter – Single-Stream ist bandbreitenlimitiert. Genau deshalb skaliert Batching überproportional: Die Gewichts-Reads werden über den Batch amortisiert. Die Community hat das jetzt vermessen:

| System | Single-Stream | Aggregiert bei Concurrency | Quelle |
|---|---|---|---|
| RTX 3090 (250 W!), vLLM getuned | ~114 t/s | **~1.000 t/s @ 64 Requests** | syv-ai |
| DGX Spark, SGLang + MTP | 33–35 t/s | **195–210 t/s @ 10 Streams** | Mia AI Lab |
| DGX Spark, SGLang + DFlash 2 / EAGLE | 28 / 26 t/s | 92 / **124 t/s @ c8** | r0b0tlab |
| H200, SGLang + DFlash 2 | 184–236 t/s | 1.090–1.368 @ c8 · **1.525–1.952 @ c32** | z-lab Model Card |
| H200 (Community-Endpoint), Spec Decoding | 70 → **126 t/s** | – | V. Mustar (HF) |

Drei Regeln daraus:

- **Speculation verliert mit steigender Last – aber unterschiedlich schnell.** Auf der 3090 lag der Crossover, ab dem pures Continuous Batching gewinnt, bei ~8 parallelen Nutzern (syv-ai). Die z-lab-H200-Messung zeigt dasselbe Muster präzise: Bei c32 fällt MTP/DSpark auf 0,77–1,13x (teils *langsamer* als autoregressiv), **DFlash 2 hält dort noch 1,16–1,45x** – der bessere Drafter verschiebt den Crossover deutlich nach hinten.
- **KV-Budget bestimmt die Concurrency:** ~64 KB/Token BF16 pro Sequenz in den 16 Full-Attention-Layern (FP8: die Hälfte) – auf einer 5090 nach NVFP4-Gewichten genug für 20+ parallele 8k-Sessions. SGLang-Stolperfalle bei diesem Hybrid-GDN-Modell: `--mamba-full-memory-ratio` (Default 0,9) überprovisioniert den KV-Pool und **deckelt still die Concurrency**.
- **Ollama/LM Studio** verarbeiten Requests weitgehend sequenziell – fürs Serving die falsche Wahl. Auf Mac und Strix Halo bleiben 2–4 parallele Streams das sinnvolle Maximum.

## Gesamtvergleich (Stand 19.08.2026)

| Hardware | Speicher | Baseline Decode | Community-getuned | Max. Kontext (praktisch) | Charakter |
|---|---|---|---|---|---|
| RTX 3090 | 24 GB | 40 t/s | **114 t/s single · ~1.000 t/s @64** | 150k–262k (getuned) | Preis-Leistungs- **und** Serving-Sieger |
| RTX 4090 | 24 GB | 46 t/s | 3090-Rezepte übertragbar, schneller | 64k+ | schnellste 24-GB-Karte |
| RTX 5090 | 32 GB | 75 t/s | **148 t/s** (Spec) · 200+ (NVFP4/SGLang) | 128k+ | Speed-König |
| RTX 5080 Laptop | 16 GB | Q3 im VRAM oder ~4 t/s (Offload) | – | 8–16k | unglückliche Mitte |
| RTX 5090 Laptop | 24 GB | ~3090-Baseline (thermisch limitiert) | Desktop-Rezepte übertragbar | 64k | die eigentliche Laptop-Wahl |
| Mac mini M4 Pro 48 GB | 273 GB/s | niedrige zweistellige t/s | MLX +~40 % | 64k+ | bester Einstiegs-Mac |
| MacBook Pro M5 Pro/Max | bis 128 GB | 28–31 t/s (GGUF) | **~40 t/s (M5 Pro, MLX)** · 33+ (M5 Max, MLX 4-Bit) · DFlash 2 via oMLX | 128k+ | mobiler Allrounder |
| Mac Studio M4 Max 64 GB | 546 GB/s | ~3090-Baseline-Klasse | MLX + DFlash 2 | 128k+ | leise Workstation |
| DGX Spark (GB10) | 128 GB | 12 t/s | **33–35 t/s single · 195–210 t/s @10** | **256k–1M** | Langkontext-Serving-Node |
| Strix Halo 128 GB | 256 GB/s | 8–11 t/s | 24–36 t/s (MTP), real 11–24 im Chat | 96k+ | Preis-Leistungs-Unified-Memory |

## Fazit

Qwen 3.8 27B ist das erste offene Modell, das Vision, 262k Kontext, Tool-Calling und ernsthafte Coding-Fähigkeiten in eine 17-GB-Datei packt. Die wichtigste Lektion der ersten Woche: **Die Hardware ist selten der Flaschenhals – der Inference-Stack ist es.** Zwischen Stock-llama.cpp und einem getunten vLLM/SGLang-Setup mit MTP oder DFlash 2 liegen Faktor 2 bis 8, auf identischer Hardware.

- **Serving & Preis-Leistung:** gebrauchte RTX 3090 + syv-ai-Stack – 114 t/s single, ~1.000 t/s im Batch, für einen Bruchteil eines Datacenter-Setups.
- **Maximaler Single-User-Speed:** RTX 5090 mit NVFP4 + Speculation (148–200+ t/s).
- **Mac:** Mac mini M4 Pro 48 GB zum Einstieg, Mac Studio M4 Max 64 GB für Komfort – in jedem Fall MLX statt GGUF, oMLX + DFlash 2 im Blick behalten.
- **Unterwegs:** MacBook Pro M5 Pro/Max ab 48 GB (~40 t/s mit MLX) oder RTX 5090 Laptop – nicht die 5080.
- **Langkontext & kleines Team:** DGX Spark mit dem Mia-AI-Lab- oder r0b0tlab-Rezept – 210 t/s aggregiert bei bis zu 1M Kontext.
- **128 GB fürs Budget:** Strix Halo, nach MTP-Tuning auf MacBook-Niveau.

Und egal wo: `reasoning_effort` auf `low`/`medium`, DFlash 2 oder MTP aktivieren, KV-Cache und Embeddings quantisieren. Diese Handgriffe entscheiden mehr als die nächste GPU-Generation.

---

*Quellen (abgerufen 15.–19.08.2026): [Qwen3.8-27B Model Card](https://huggingface.co/Qwen/Qwen3.8-27B) · [Hardware-Corner-Benchmarks](https://www.hardware-corner.net/qwen3-8-27b-hardware-tests/) · [Simon Willison](https://simonwillison.net/2026/Aug/16/qwen-38-27b/) · [syv-ai/qwen38-27b-rtx3090 (GitHub)](https://github.com/syv-ai/qwen38-27b-rtx3090) · [MiaAI-Lab/Qwen3.8-27B-SGLang-DGX-Spark (GitHub)](https://github.com/MiaAI-Lab/Qwen3.8-27B-SGLang-DGX-Spark) & [@MiaAI_lab auf X](https://x.com/miaai_lab) · [r0b0tlab/qwen38-27b-nvfp4-sm121-sglang (GitHub)](https://github.com/r0b0tlab/qwen38-27b-nvfp4-sm121-sglang) · [Inco AI: DFlash 2](https://inco.ai/blog/dflash2/) & [z-lab/Qwen3.8-27B-DFlash2 (H200-Benchmarks)](https://huggingface.co/z-lab/Qwen3.8-27B-DFlash2) · [RTX-5090-Speculative-Setup (note.com)](https://note.com/unco3/n/n50897cea0ae5) · [50 t/s auf 24-GB-Blackwell bei 256k (piszczek.pl)](https://piszczek.pl/blog/qwen38-27b-256k-50-tps-24gb-gpu) · [KGP Talkie: 45 llama.cpp-Konfigurationen](https://kgptalkie.com/tutorials/generative-ai/qwen-3-8-27b-llama-cpp-speed-settings) · [@witcheer](https://x.com/witcheer/status/2088316316205907970), [@victormustar](https://x.com/victormustar/status/2088753441304727779) & [@0xSero](https://x.com/0xSero/status/2089421053852258334) auf X · [MLX-Messwerte M5 Max](https://huggingface.co/malekoo/Qwen3.8-27B-MLX-8bit) & [mlx-community](https://huggingface.co/mlx-community/Qwen3.8-27B-8bit) · [Unsloth GGUF-Repo & Guide](https://unsloth.ai/docs/models/qwen3.8) · [AMD Day-0-Blog](https://www.amd.com/en/blogs/2026/run-qwen-3-8-27b-on-amd-ryzen-ai-max-and-radeon-graphics-cards-day-0.html) · [julianmb/q38rocm](https://github.com/julianmb/q38rocm) & [KyaniteLabs](https://github.com/KyaniteLabs/qwen38-27b-strix-halo) (GitHub) · [SGLang-Cookbook](https://docs.sglang.io/cookbook/autoregressive/Qwen/Qwen3.8-27B) · [Kingy.ai Hardware-Guide](https://kingy.ai/blog/qwen3-8-27b-local-hardware-requirements/) · [VentureBeat](https://venturebeat.com/technology/qwen3-8-27b-runs-frontier-class-coding-agents-and-reasoning-locally-no-cloud-api-required). Alle Werte sind Community- bzw. Herstellermessungen aus den ersten fünf Tagen nach Release; Software-Stände ändern sich täglich.*

## Sources

- [Qwen3.8-27B Model Card](https://huggingface.co/Qwen/Qwen3.8-27B)
- [Hardware-Corner-Benchmarks](https://www.hardware-corner.net/qwen3-8-27b-hardware-tests/)
- [Simon Willison](https://simonwillison.net/2026/Aug/16/qwen-38-27b/)
- [syv-ai/qwen38-27b-rtx3090 (GitHub)](https://github.com/syv-ai/qwen38-27b-rtx3090)
- [MiaAI-Lab/Qwen3.8-27B-SGLang-DGX-Spark (GitHub)](https://github.com/MiaAI-Lab/Qwen3.8-27B-SGLang-DGX-Spark)
- [@MiaAI_lab auf X](https://x.com/miaai_lab)
- [r0b0tlab/qwen38-27b-nvfp4-sm121-sglang (GitHub)](https://github.com/r0b0tlab/qwen38-27b-nvfp4-sm121-sglang)
- [Inco AI: DFlash 2](https://inco.ai/blog/dflash2/)

---

## Lokale KI für euer Team aufsetzen

Wir planen und installieren lokale LLM-Setups für Unternehmen: Hardware-Auswahl (DGX Spark, RTX, Mac Studio), Modellwahl, privates Deployment und Übergabe. Ihr bekommt ein System, das auf eigener Hardware läuft und Daten im Haus behält.

Mit einem Workshop starten – danach Scoping und Festpreis-Angebot.

**[Workshop anfragen →](https://www.contextstudios.ai/de/leistungen/ai-workshop?utm_source=blog&utm_medium=cta&utm_campaign=qwen-3-8-27b-hardware-guide)**


## Related

- [KI-Entwicklung](https://www.contextstudios.ai/de/ki-entwicklung.md)
- [KI-Agent-Entwicklung](https://www.contextstudios.ai/de/ki-agent-entwicklung.md)
- [KI-Beratung](https://www.contextstudios.ai/de/ki-beratung.md)
- [KI-Agentur](https://www.contextstudios.ai/de/ki-agentur.md)