Gemma 3 auf dem Mac: Varianten, Vision und Speichergrenzen

Aktualisiert am 12. Oktober 2026. Gemma 4 ist Googles neuere offene Modellfamilie. Gemma 3 gibt es auf dem Mac für unterschiedliche Unified-Memory-Größen: Ollama führt kleine Tags, und die 4B-, 12B- und 27B-Varianten sind als multimodal gelistet. Maßgeblich sind Paketgröße, Kontext und freier Unified Memory.

Welche Gemma-3-Variante passt zu welchem Mac?

Mac	Erster Kandidat	Einordnung
8 GB	gemma3:1b für Text; gemma3:4b nur für Bilder testen	806 MB/3,4 GB Downloadgröße, kein Laufzeit-RAM-Versprechen
16 GB	gemma3:4b, gemma3:12b nur nach RAM-Test	12B belegt rund 8,2 GB als Download; Kontext und andere Programme brauchen weitere Kapazität
24–32 GB	gemma3:12b	mehr Reserve als 27b; 27b mit 17 GB nur mit bewusster Speicherplanung
48 GB+	gemma3:27b	größere lokale Variante, aber 128K Kontext bleibt eine Belastungsgrenze

In der Modellbibliothek von Ollama finden sich ergänzend gemma3:270m und gemma3:1b. Diese beiden kompakten Varianten sind reine Textmodelle mit 32K Kontext. Die 4B-, 12B- und 27B-Tags sind laut Ollama multimodal ausgelegt und mit 128K Kontext gelistet.

Die Tag-Dateien ändern sich: Am 12. Oktober listet Ollama 1B mit 806 MB, 4B mit 3,4 GB und 12B mit 8,2 GB (zuvor 815 MB, 3,3 GB, 8,1 GB). ollama list zeigt, welche Version bei dir installiert ist. Paketgröße ist nicht der gesamte RAM-Bedarf: Runtime, KV-Cache, macOS, Bilder und parallele Apps kommen hinzu. Ein Startlauf schließt Speicherdruck oder CPU-Offloading bei langen Prompts nicht aus.

Gemma 3 in Ollama starten

8-GB-Macs: Für reine Textaufgaben zuerst den kleineren 1B-Tag verwenden; 270m ist noch kleiner. Nur die 4B-/12B-/27B-Varianten unterstützen in Ollamas aktueller Liste Bilder. Die 4B-Variante anschließend mit kurzem Kontext und wenigen parallelen Programmen testen, statt von der Downloadgröße auf die Leistung zu schließen.

ollama pull gemma3:1b
ollama run gemma3:1b

Für den kleineren Vision-Einstieg:

ollama pull gemma3:4b
ollama run gemma3:4b

Ein Bild kann in der Ollama-App oder über einen kompatiblen Client mit einer Frage kombiniert werden. Die passende Variante ist entscheidend: 270m und 1b sind in der aktuellen Ollama-Liste Textmodelle; für Bildinput brauchst du einen multimodalen Tag wie 4b, 12b oder 27b.

Für eine größere lokale Variante:

ollama pull gemma3:12b
ollama run gemma3:12b

Die QAT-Tags (gemma3:4b-it-qat, 12b-it-qat und 27b-it-qat) sind quantization-aware-trained Varianten. Ollama beschreibt sie als speichereffizienter bei ähnlicher Qualität zur Halbpräzision. Die Angabe beschreibt Modell und Quantisierung; die Geschwindigkeit hängt trotzdem vom jeweiligen Mac ab.

Was Vision praktisch verändert

Bildinput erhöht den Speicher- und Rechenaufwand gegenüber einer reinen Textfrage. Ein Screenshot, ein PDF-Render oder ein Foto wird zunächst in visuelle Tokens beziehungsweise Encoder-Ausgaben übersetzt. Bei knappen 8- oder 16-GB-Systemen solltest du deshalb nicht gleichzeitig ein großes Modell, einen langen Textkontext und viele Bilder laden.

Für kleinere lokale Bildaufgaben ist Gemma 3 4B geeignet, etwa für:

• einzelne Screenshots,
• einfache Dokumentbilder,
• kurze Bildbeschreibungen,
• grobe UI- oder Layout-Fragen.

Für komplexe OCR, lange Dokumente oder anspruchsvolle visuelle Schlussfolgerungen ist die Modellgröße nur ein Faktor. Eingabeauflösung, Prompt, Kontext und tatsächliche Fehlertoleranz des Workflows müssen separat geprüft werden.

Eigenes Bild lokal auswerten: Python-Beispiel

Ein öffentlich erreichbarer Bildlink ist nicht erforderlich. Das offizielle Ollama-Python-SDK akzeptiert lokale Bildpfade, Bild-URLs oder Bytes. Für die rohe REST-API erwartet Ollama dagegen Base64-kodierte Bilddaten. Nach dem Download von gemma3:4b und pip install ollama:

from pathlib import Path
from ollama import chat

image_path = Path.home() / "Desktop" / "screenshot.png"
if not image_path.is_file():
    raise FileNotFoundError(image_path)

result = chat(
    model="gemma3:4b",
    messages=[{
        "role": "user",
        "content": "Beschreibe das Bild. Gib unsichere OCR-Stellen an.",
        "images": [str(image_path)],
    }],
)
print(result.message.content)

Damit wird das Bild an den konfigurierten Ollama-Server übergeben. Ist das wie üblich 127.0.0.1:11434 auf deinem Mac und sind keine Cloud-Tools aktiv, bleibt diese Bildanalyse lokal. Bei einem Remote-Server oder Drittanbieter-Agenten gilt diese Aussage nicht. Prüfe kleine Bildschrift und Fakten, statt OCR-Ergebnisse ungeprüft zu übernehmen.¹

Die 128K-Kontextangabe richtig lesen

Ollama listet für die multimodalen Gemma-3-Tags bis zu 128K Kontext. 128K ist das Modelllimit. Der KV-Cache wächst mit der Kontextlänge; bei Vision-Aufgaben kommen Bildtokens und temporäre Puffer hinzu. Ob ein Mac den Kontext komfortabel berechnet, hängt zusätzlich von Speicher und Systemlast ab.

Starte deshalb mit einer niedrigeren Kontextlänge und erhöhe sie nur, wenn dein Workflow sie benötigt. Nach dem Laden hilft:

ollama ps

Achte auf Kontext, Modellgröße und Prozessor-Aufteilung. Wenn Teile auf die CPU ausgelagert werden oder macOS Speicherdruck meldet, reduziere zuerst Kontext und parallele Programme.

Safety, Terms und Grenzen

Googles Gemma-3-Model-Card dokumentiert interne Safety-Evaluierungen und Verbesserungen gegenüber früheren Gemma-Modellen. Die Ergebnisse stammen aus Googles Hersteller-Evaluierung und belegen keine sicheren Ausgaben in deiner lokalen Anwendung. Die dokumentierten Tests beschränkten sich laut Model Card ausschließlich auf englischsprachige Prompts.

Für produktive oder agentische Workflows brauchst du deshalb eigene Eingabe-/Ausgabekontrollen, ein eingeschränktes Tool- und Dateisystem-Rechtemodell und eine Prüfung riskanter Aktionen. Für Bildanwendungen kann ShieldGemma 2 als separates Safety-Modell eingesetzt werden; es ist kein automatisch aktivierter Filter in gemma3:4b.

Die Gewichte werden über Googles Gemma Terms of Use bereitgestellt. Verwechsle diese Nutzungsbedingungen nicht mit einer pauschalen Apache-2.0-Aussage für jeden Gemma-3-Download oder jede Community-Konvertierung.

Gemma 3 oder Gemma 4?

Gemma 4 ist die neuere Generation und bietet zusätzliche Größen, MoE-Varianten sowie neuere Reasoning- und Agentenfunktionen. Gemma 3 passt besser, wenn:

• du einen konkreten Gemma-3-Checkpoint benötigst, der bereits in deinem Workflow getestet wurde,
• ein bestehender Workflow genau Gemma 3 erwartet,
• du einen kleinen und gut dokumentierten Vision-Tag benötigst,
• eine ältere Modellgeneration für deine Aufgabe ausreichend ist.

Auch Gemma 4 E2B ist eine lokale Option für kleinere Macs, je nach tatsächlichem Tag laut Ollama mit 4,6–7,5 GB Paketgröße. Daraus folgt weder, dass E2B auf jedem 8-GB-Mac flüssig läuft, noch dass es Gemma 3 4B qualitativ bei jedem Prompt übertrifft. Modelle und Kontext mit demselben Test vergleichen. Ollama: Gemma 4.

Richte die Auswahl nach Unified Memory und Aufgabe aus. Auf einem größeren Mac kann ein Gemma-4-Tag besser passen; auf einem knappen Mac kann ein Gemma-3-4B-Tag mehr Spielraum lassen als ein größeres neues Modell. Für die neuere Generation siehe den Gemma-4-RAM-Guide und die Gemma-4-12B-Einordnung.

Gemma 3 mit belastbaren Mac-Messungen testen

Lokal messen: Ollamas Token- und Zeitmetrik

Statt unbelegte Geschwindigkeitstabellen zu übernehmen, kannst du gemma3:1b und gemma3:4b direkt auf deinem eigenen Mac über die lokale Ollama Generate API vergleichen. Der API-Response liefert eval_count und eval_duration (Nanosekunden). Die Ausgabe-Tokens pro Sekunde sind eval_count × 1e9 / eval_duration. Das ist nicht die Gesamtlatenz und auch kein Bild-Benchmark.

import json
from urllib.request import Request, urlopen

for model in ("gemma3:1b", "gemma3:4b"):
    body = {
        "model": model,
        "prompt": "Nenne drei praktische Einsatzfelder lokaler KI.",
        "stream": False,
        "options": {"num_ctx": 2048, "num_predict": 128},
        "keep_alive": 0,
    }
    request = Request(
        "http://127.0.0.1:11434/api/generate",
        data=json.dumps(body).encode("utf-8"),
        headers={"Content-Type": "application/json"},
    )
    with urlopen(request, timeout=180) as response:
        result = json.load(response)
    count = result.get("eval_count", 0)
    duration = result.get("eval_duration", 0)
    print(model, {
        "output_tokens": count,
        "tokens_per_s": round(count * 1e9 / duration, 1) if duration else None,
        "load_s": round(result.get("load_duration", 0) / 1e9, 2),
        "total_s": round(result.get("total_duration", 0) / 1e9, 2),
    })

Vorher beide Tags mit ollama pull herunterladen und den lokalen Ollama-Dienst starten. keep_alive: 0 entlädt jedes Modell nach der Antwort, damit ein 8-GB-Test nicht beide gleichzeitig im Speicher belässt. Das Skript verbindet sich ausschließlich mit 127.0.0.1; fehlende lokale Modelle lösen Fehler aus statt eines heimlichen Cloud-Fallbacks. Die Ausgabe enthält keine generierten Texte. Mehrfach messen, Warm-/Kaltstarts unterscheiden und in der macOS-Aktivitätsanzeige Speicher und Swap kontrollieren. Das Beispiel ist kein hier durchgeführter Benchmark.

Die aktuelle Ollama-Tag-Liste unterscheidet 270m (292 MB) und 1b (806 MB), beide reine Textmodelle mit 32K Kontext, von 4b (3,4 GB), 12b (8,2 GB) und 27b (17 GB) mit Bild- und Texteingabe und einem Modelllimit von 128K Kontext. Paketgröße ist nicht der tatsächliche RAM-Bedarf; aus dem 128K-Limit folgt keine Garantie für einen ausreichend großen KV-Cache im Unified Memory.

ollama pull gemma3:4b
ollama show gemma3:4b
ollama run gemma3:4b

Im interaktiven Ollama-Chat beginne mit /set parameter num_ctx 4096. Prüfe über ollama ps in einem zweiten Terminal, welches Modell tatsächlich läuft. Speicherdruck und Swap von macOS misst du dagegen in Aktivitätsanzeige → Speicher: ollama ps ist kein vollständiger System-RAM-Monitor. Teste Qualität, Prompt-Verarbeitung und Output-Tempo mit denselben drei Aufgaben: kurzer Text, kleiner Screenshot und längeres Dokument.

Auf einem 8-GB-Mac zuerst 1B für reine Textaufgaben verwenden; 4B nur bei notwendigem Bildinput mit kurzem Kontext testen. 12B/27B wählst du nach tatsächlich verfügbarem Speicher und gemessener Antwortzeit, nicht allein nach 8,2/17 GB Downloadgröße. Für die Gewichte gelten Googles Gemma Terms of Use; Gemma 4 ist eine separat zu vergleichende neuere Familie.

Quellen

• Ollama: Gemma 3 – aktuelle Tags, Paketgrößen, Modalitäten und Kontextangaben.
• Google: Introducing Gemma 3 – Modellfamilie, Größen und Vision-Unterstützung.
• Google: Gemma 3 Model Card – Kontext, Modalitäten, Evaluierung und Limitationshinweise.
• Google Developers Blog: Introducing Gemma 3 – Developer-Workflow und Funktionsumfang.
• Gemma 3 Technical Report – Architektur, Vision-Encoder und KV-Cache-Kontext.
• Gemma Terms of Use – Bedingungen für die Nutzung der Gewichte.
• Ollama Vision – lokale Pfade und Bytes im Python-SDK, Base64 in der REST-API.
• Ollama Generate API – genaue Tokenzähler, Nanosekunden-Zeitangaben und keep_alive.
• Ollama Gemma 4 – aktuelle Alternativen und paketabhängige Modellgrößen.

Footnotes

1. https://docs.ollama.com/capabilities/vision ↩