Gemma 4 26B oder Qwen3.6 27B: Welches Modell passt besser zum Mac?

Für ein neues Mac-Setup gibt es keinen pauschalen Sieger. Gemma 4 26B A4B ist ein Mixture-of-Experts-Modell (MoE), das bei der Tokenberechnung etwa 3,8 Milliarden Parameter aktiviert. Qwen3.6 27B ist ein dichtes Modell mit Schwerpunkt auf Coding und Agenten. Beide unterstützen Text- und Bildeingaben. Für beide gibt es explizite Q4_K_M-Tags in Ollama. Ob ein Modell auf deinem Mac besser ist, lässt sich nur mit vergleichbaren Aufgaben beurteilen.

Aktualisiert am 13. Oktober 2026: Qwen3.6 ist nicht mehr die jüngste Version. Für ein neues Mac-Setup gehört der offiziell veröffentlichte Qwen3.8 27B Q4_K_M als dritter, optionaler Kandidat in den Test; Ollama listet dafür 18 GB Download, 256K Modellkontext und den Tag-Digest 25b843619e94. Das ist keine Messung von Geschwindigkeit oder Arbeitsspeicher. Den bisherigen 3.6-Vergleich behalten wir für bestehende Installationen bei. Zum neueren Modell verweisen wir ergänzend auf den ausführlichen Mac-Ratgeber.

Architektur und Ollama-Paketgrößen

Merkmal	Gemma 4 26B A4B	Qwen3.6 27B
Architektur	MoE: 25,2 Mrd. gesamt, 3,8 Mrd. aktiv	Dense-Modell, vermarktet als 27B
Eingaben	Text und Bild	Text und Bild
Ollama-Q4_K_M-Tag	gemma4:26b-a4b-it-q4_K_M	qwen3.6:27b-q4_K_M
Paketgröße	18 GB	17 GB
Gelistetes Modell-Kontextfenster	bis 256K Tokens	bis 256K Tokens
Unified Memory auf dem Mac	Für diese Quantisierungen eher mit 32 GB oder mehr planen, abhängig von Kontext und parallelen Apps.	Gleiche Einschränkung.

Die Paketgrößen und Modalitäten stammen aus den konkreten Ollama-Tags für Gemma 4 und Qwen3.6, geprüft am 11. Oktober 2026. Architektur und Parameterzahlen stehen in Googles Modellkarte beziehungsweise Qwens Modellkarte.

Warum andere Ollama-Seiten andere Größen nennen: Dieser Vergleich bezieht sich ausdrücklich auf die älteren, explizit benannten Q4_K_M-Tags gemma4:26b-a4b-it-q4_K_M (18 GB, Build 5571076f3d70) und qwen3.6:27b-q4_K_M (17 GB, Build 3a40c32f1450). Die aktuellen Familienübersichten zeigen für das nicht identische Standard-Tag gemma4:26b dagegen 16–19 GB und für qwen3.6:27b 18–19 GB. Das ist kein Widerspruch: Der Alias verweist nicht zwingend auf dieselbe Datei oder Quantisierung wie das explizite Q4-Tag. Vor einem Kosten-, RAM- oder Geschwindigkeitstest beide Modell-Digests mit ollama show und ollama list dokumentieren. Die Standard-Tag-Bereiche und weitere Modelle stehen im Mac-LLM-Auswahlguide. Keine dieser Paketgrößen ist eine gemessene RAM-Belegung.

Der dritte Kandidat für Neuinstallationen: Qwen3.8 27B

In Ollamas offizieller Tagliste steht qwen3.8:27b-q4_K_M mit 18 GB, 256K Modellkontext und Text-/Bildeingabe. Für einen faireren Versionswechsel behältst du Qwen3.6 als ältere Kontrollgruppe und testest Qwen3.8 separat – die Modellfamilie verspricht Verbesserungen, aber das ist kein eigener Qualitätsnachweis.

Expliziter Ollama-Tag	Downloadgröße	Warum im Test?
gemma4:26b-a4b-it-q4_K_M	18 GB	MoE und anderes Modelltraining
qwen3.6:27b-q4_K_M	17 GB	Vorhandene Installation als Baseline
qwen3.8:27b-q4_K_M	18 GB	Aktueller Qwen-Kandidat für Neuinstallationen

Bei drei separaten Downloads sind die gelisteten Paketgrößen zusammen rechnerisch 53 GB; Ollama kann Blobs wiederverwenden, deshalb ist das keine garantierte Festplattenbelegung. Nur qwen3.8:27b-q4_K_M laden, wenn du ihn wirklich vergleichen willst. Die 18 GB sind keine RAM-Empfehlung, und die drei Modelle haben nicht automatisch gleiche Reasoning-Modi.

MoE ist kein kostenloser Arbeitsspeicher

Gemma 4 26B A4B hat laut Google 25,2 Milliarden Gesamtparameter, von denen bei der Verarbeitung eines Tokens etwa 3,8 Milliarden aktiv sind. Das kann Rechenaufwand sparen. Die übrigen Expertengewichte müssen trotzdem gespeichert und erreichbar sein. Gemma 4 26B unterstützt Text und Bilder, aber in dieser Größe kein Audio; Audio-Unterstützung bietet Google bei anderen Gemma-4-Varianten an.

Qwen3.6 27B verwendet eine dichte Architektur. Qwens offizielle Modellkarte dokumentiert Bildverarbeitung. Auch die Ollama-Tags für qwen3.6:27b führen Text- und Bildeingaben. Bei alternativen Konvertierungen und Runtimes muss man die multimodale Unterstützung jeweils separat prüfen.

Die Architektur allein beweist weder eine höhere Tokenrate noch bessere Coding-Qualität. Dafür zählen Modellversion, Quantisierung, Kontext, Mac-Chip und Runtime.

Reproduzierbare Installation

Mit Ollama auf macOS lädst du die expliziten Varianten:

ollama pull gemma4:26b-a4b-it-q4_K_M
ollama pull qwen3.6:27b-q4_K_M
# Optional für neue Setups, benötigt weiteren Download:
# ollama pull qwen3.8:27b-q4_K_M
ollama show gemma4:26b-a4b-it-q4_K_M
ollama show qwen3.6:27b-q4_K_M

Zum Starten verwendest du jeweils:

ollama run gemma4:26b-a4b-it-q4_K_M
ollama run qwen3.6:27b-q4_K_M

Die Tag-Namen fixieren die Quantisierungsklasse. Für streng reproduzierbare Tests solltest du zusätzlich die Modell-Digests aus Ollama dokumentieren, denn auch ein benannter Tag kann aktualisiert werden. Ein GGUF-Q4_K_M-Tag ist nicht direkt mit einem MLX-/NVFP4-Build vergleichbar.

Wie viel RAM braucht der Mac?

Ein 18-GB-Download belegt zur Laufzeit nicht zwangsläufig nur 18 GB. Zu den Gewichten kommen KV-Cache, Arbeitsbuffer, Vision-Verarbeitung, macOS und weitere Anwendungen. Mit 24 GB Unified Memory kann es bei beiden Modellen je nach Kontext schnell eng werden. 32 GB sind für einen begrenzten Kontext der sinnvollere Einstieg; 48 GB bieten mehr Reserve für längere Sitzungen und IDEs.

Die beworbenen 256K Tokens Kontext sind keine Zusage für einen flüssigen Betrieb auf einem 32-GB-Mac. Starte mit kleinerem Kontext, kontrolliere den Speicherdruck in der macOS-Aktivitätsanzeige und die geladenen Modelle mit ollama ps. Für konkrete Größen hilft der Mac-LLM-RAM-Rechner.

Was der Gemma-4-MLX-Benchmark wirklich zeigt

Ollama meldete am 29. Juni 2026 einen Geschwindigkeitsgewinn von rund 90 Prozent durch Multi-Token Prediction (MTP) im Aider-polyglot-Benchmark. Der gezeigte Test verwendete jedoch Gemma 4 12B in NVFP4 auf einem M5 Max. Das ist eine Anbietermessung mit einem anderen Modellcheckpoint — keine Bestätigung, dass gemma4:26b-a4b-it-q4_K_M 90 Prozent schneller läuft oder schneller als Qwen3.6 27B ist. Quelle: Ollama.

Laut Ollama hängt der praktische Nutzen von MTP maßgeblich von der jeweiligen Aufgabenstellung ab. Wer MLX-Leistung messen möchte, muss den konkret getesteten MLX-Tag, die Ollama-Version und die aktive Beschleunigung festhalten.

So vergleichst du beide Modelle sinnvoll

Verwende fünf bis zehn echte Aufgaben: Repository-Änderungen mit Tests, eine mehrstufige Tool-Aufgabe und bei Bedarf überprüfbare Bilder. Halte Kontext, Sampling, Quantisierung und Hintergrundlast möglichst konstant. Protokolliere Ladezeit, Promptverarbeitungszeit, Ausgabetokens pro Sekunde, Speicherdruck und vor allem erfolgreiche Aufgaben. Die unten verwendete nicht-streamende API kann keine echte Zeit bis zum ersten Token (TTFT) liefern: Dafür brauchst du einen separaten Streaming-Test. Notiere Ollama-Version und Modelldigests. Der Code liest die lokale Modellidentität aus /api/tags, aber eine erfolgreiche Modellantwort ist noch kein Qualitätsnachweis. Qwen3.8 hat eigene Thinking-Defaults; gleiche Temperatur garantiert deshalb keine gleichen Reasoning-Budgets.

Ein schnelleres Modell kann durch Fehlversuche und Nacharbeit insgesamt schlechter abschneiden. Umgekehrt darf ein Modell nicht allein wegen seiner MoE-Architektur zum Coding-Sieger erklärt werden. Ein unabhängig gemessener Mac-Direktvergleich liegt diesem Artikel nicht zugrunde.

Messprotokoll: zwei Basismodelle plus optional Qwen3.8

Das Beispiel nutzt ausschließlich Pythons Standardbibliothek und die lokalen Ollama-Endpunkte Modellliste /api/tags und Generate /api/generate. Es prüft vor dem ersten Generieren alle drei beziehungsweise beide exakten Modell-Tags und protokolliert Ollamas lokale Digests sowie die Quantisierung; fehlt ein benötigter Download, endet es mit einer verständlichen Fehlermeldung. Voraussetzung: Ollama läuft, die beiden Basismodelle sind heruntergeladen. Optional ergänzt INCLUDE_QWEN38=1 das neuere Modell (vorher mit ollama pull qwen3.8:27b-q4_K_M laden). Mit RUNS=3 führst du drei Durchläufe pro Modell aus. Der Code ruft sie nacheinander auf und fordert mit keep_alive: 0 nach jeder Antwort die Entladung an. Damit wird die modellbezogene Ladezeit je Anfrage erfasst; ein vollständig kalter System-/Dateicache wird nicht erzwungen. Bereits geladene Modelle und andere Prozesse können die Werte beeinflussen. Er schickt keine Daten an eine externe Cloud-API. Antwortinhalte werden nur bei SHOW_OUTPUT=1 angezeigt, zum eigenen Qualitätscheck.

python3 - <<'PY'
import json
import os
from urllib.error import HTTPError, URLError
from urllib.request import Request, urlopen

models = ["gemma4:26b-a4b-it-q4_K_M", "qwen3.6:27b-q4_K_M"]
if os.environ.get("INCLUDE_QWEN38") == "1":
    models.append("qwen3.8:27b-q4_K_M")
repeats = max(1, min(5, int(os.environ.get("RUNS", "1"))))
prompt = "Explain two concrete race conditions in a Python producer-consumer queue and show a corrected short code example."
base = "http://127.0.0.1:11434"
if any(tag.endswith(":cloud") for tag in models):
    raise SystemExit("Cloud models are not eligible for this local comparison")
try:
    with urlopen(base + "/api/tags", timeout=15) as response:
        installed = {entry["name"]: entry for entry in json.load(response)["models"]}
except (HTTPError, URLError, KeyError, ValueError) as error:
    raise SystemExit("Local Ollama model inventory unavailable: " + str(error))
missing = [tag for tag in models if tag not in installed]
if missing:
    raise SystemExit("Download these exact local model tags first: " + ", ".join(missing))

for model in models:
    entry = installed[model]
    print(json.dumps({
        "model_identity": model,
        "digest": entry.get("digest"),
        "quantization": (entry.get("details") or {}).get("quantization_level"),
        "listed_package_bytes": entry.get("size"),
        "requested_runs": repeats,
    }))
    for run in range(1, repeats + 1):
        payload = {
            "model": model,
            "prompt": prompt,
            "stream": False,
            "keep_alive": 0,
            "options": {"num_ctx": 4096, "num_predict": 512, "temperature": 0},
        }
        request = Request(
            base + "/api/generate",
            data=json.dumps(payload).encode("utf-8"),
            headers={"Content-Type": "application/json"},
        )
        try:
            with urlopen(request, timeout=900) as response:
                result = json.load(response)
        except (HTTPError, URLError, ValueError) as error:
            raise SystemExit(f"{model} run {run}: local generation failed: {error}")
        count = result.get("eval_count", 0)
        duration = result.get("eval_duration", 0)
        print(json.dumps({
            "model": model,
            "run": run,
            "output_tokens": count,
            "tokens_per_second": round(count * 1e9 / duration, 2) if duration else None,
            "prompt_seconds": round(result.get("prompt_eval_duration", 0) / 1e9, 2),
            "load_seconds": round(result.get("load_duration", 0) / 1e9, 2),
            "total_seconds": round(result.get("total_duration", 0) / 1e9, 2),
            "done_reason": result.get("done_reason"),
            "response_chars": len(result.get("response") or ""),
        }))
        if os.environ.get("SHOW_OUTPUT") == "1":
            print((result.get("response") or "")[:1500])
PY

eval_count / eval_duration ergibt Ausgabetokens pro Sekunde, nicht TTFT. Die Ollama-Felder load_duration, prompt_eval_duration und total_duration liefern getrennte Nanosekunden-Zeiten; das Skript zeigt sie in Sekunden. Für Wiederholungen die erste Shell-Zeile als RUNS=3 python3 - <<'PY' ausführen; für den optionalen Dreiervergleich RUNS=3 INCLUDE_QWEN38=1 python3 - <<'PY' verwenden. Speicherdruck und Swap in Aktivitätsanzeige → Speicher notieren und Fälle mit done_reason: "length" als abgebrochen kennzeichnen. Das Skript begrenzt Ausgaben bewusst auf 512 generierte Tokens; bei langen Thinking-Ausgaben reicht das möglicherweise nicht für eine vollständige Antwort. Ein Durchlauf allein ist kein Qualitätsranking.

Prüfe schließlich den inhaltlichen Erfolg: Enthält die Antwort tatsächlich zwei korrekte Race Conditions und ausführbaren, getesteten Beispielcode? Schreibe Fehlversuche genauso auf wie erfolgreiche Antworten. Hier werden bewusst keine gemessenen Mac-Werte behauptet. Die Methode folgt den dokumentierten Ollama-Laufzeitfeldern und kann mit den eigenen Modell-Digests wiederholt werden.

Fazit für vorhandene und neue Setups

Gemma 4 26B A4B ist einen Versuch wert, wenn MoE-Inferenz oder multimodale Aufgaben im Mittelpunkt stehen. Qwen3.6 27B bleibt interessant, wenn du bereits einen Coding-/Agenten-Workflow damit betreibst. Für einen Neukauf oder eine frische Installation solltest du Qwen3.8 in denselben Test aufnehmen. Entscheidend ist, welche Variante deine Aufgaben innerhalb deines realen Speicherbudgets zuverlässig erledigt.

Quellenstand: 12. Oktober 2026: Gemma-4-Modellkarte · Qwen3.6-Modellkarte · Gemma-4-Ollama-Tags · Qwen3.6-Ollama-Tags · Ollama-MTP-Messung · Qwen3.8 Q4_K_M.