Raspberry Pi 5 mit Aktivkühler vor einem Display mit Terminalausgabe von LiteRT und dem Gemma-Modell

Gemma 4 lokal auf dem Raspberry Pi 5: LiteRT im Praxistest

Ein Sprachmodell wie Gemma 4 komplett offline auf dem Raspberry Pi 5 laufen zu lassen, ist längst kein Kunststück mehr – neu ist, dass Raspberry Pi selbst einen Weg dafür empfiehlt. Am 11. August 2026 haben Google AI Edge und Raspberry Pi eine gemeinsame Ankündigung veröffentlicht: Googles Laufzeitumgebung LiteRT ist jetzt für den Pi 5 optimiert, inklusive Sprachmodellen aus der Gemma-Familie und einer experimentellen GPU-Beschleunigung.

Ich habe mir angeschaut, was davon in der Praxis übrig bleibt: Wie die Installation abläuft, wie schnell Gemma auf dem Pi wirklich antwortet, wie viel Arbeitsspeicher das Ganze frisst – und ob sich der Umstieg von Ollama lohnt. In dieser Anleitung richtet ihr LiteRT Schritt für Schritt ein und lasst euer erstes Modell lokal antworten.

Kurz gesagt

Auf dem Pi 5 mit 4 GB ist LiteRT der Weg, Gemma 4 E2B lokal laufen zu lassen – Ollama scheitert dort mit demselben Modell am Speicher. Auf dem 8-GB-Pi oder mit kleineren Modellen bleibt Ollama der bequemere Weg zum Chatbot.

  • Ihr braucht: einen Pi 5, Raspberry Pi OS in 64 Bit, aktive Kühlung und rund 10 GB freien Speicher – kein AI HAT
  • Installation: Python-Paket litert-cli über uv, die Sprachmodell-Teile lädt das CLI beim ersten Aufruf selbst nach
  • Stärken: geringer Speicherbedarf, Bilderkennung und Sprachmodell mit demselben Werkzeug
  • Schwächen: kleinere Modellauswahl als Ollama, GPU-Beschleunigung noch langsamer als die CPU
Was ist LiteRT?

LiteRT ist Googles Laufzeitumgebung für KI-Modelle auf Endgeräten und der direkte Nachfolger von TensorFlow Lite. Sie führt klassische ML-Modelle und Sprachmodelle lokal auf CPU oder GPU aus – seit August 2026 offiziell für den Raspberry Pi 5 optimiert, inklusive der LLM-Schicht LiteRT-LM. Kostenlos und quelloffen.

Was Google und Raspberry Pi da angekündigt haben

Die Ankündigung erschien zeitgleich im Raspberry-Pi-Newsblog und auf Googles Entwicklerblog – solche gemeinsamen Auftritte gibt es selten. Der Kern: Google hat LiteRT gezielt für die Hardware des Pi 5 optimiert und liefert gleich drei Dinge mit.

Erstens Sprachmodelle. Über eine Zwischenschicht namens LiteRT-LM laufen Modelle der Gemma-Familie direkt auf dem Pi – von Gemma 3 270M für einfache Aufgaben wie Textklassifikation bis zu Gemma 4 E4B, das Google als besten Kompromiss aus Größe und Können bezeichnet. Für diese Anleitung nehme ich das kleinere Gemma 4 E2B: Es ist auf knappen Arbeitsspeicher getrimmt und das Beispielmodell der offiziellen Anleitung.

Zweitens die GPU. Die VideoCore VII des Pi 5 lässt sich jetzt für Inferenz nutzen. Möglich macht das experimenteller WebGPU-Support im offenen Vulkan-Treiber V3DV, den Igalia im Rahmen der langjährigen Zusammenarbeit mit Raspberry Pi in Mesa eingebaut hat.

Drittens ein schlankes Kommandozeilenwerkzeug, das Modelle herunterlädt, ausführt, misst und konvertiert – und dabei nur die Teile nachlädt, die ihr tatsächlich braucht.

Die offiziellen Messwerte

Google hat für den Pi 5 mit 8 GB RAM Zahlen veröffentlicht, gemessen mit vier Threads bei 1.024 Eingabe- und 256 Ausgabe-Token:

ModellLaufzeitumgebungEingabe (Token/s)Ausgabe (Token/s)Spitzen-RAM
Gemma 4 E2BLiteRT-LM9991.432 MB
Gemma 4 E2Bllama.cpp2444.406 MB

Das sieht nach einem Erdrutschsieg aus – vierfaches Tempo beim Einlesen, ein Drittel des Speicherbedarfs. Zwei Details sollte man dabei aber kennen. Erstens vergleicht Google ein Modell in QAT-Quantisierung (Quantization-Aware Training – das Modell wird schon beim Training auf die verkleinerte Zahlendarstellung vorbereitet und verliert dadurch weniger Qualität) mit einer klassisch nachträglich quantisierten Q4_0-Variante bei llama.cpp. Zweitens stehen im Anhang derselben Ankündigung für llama.cpp andere Werte: 58 Token/s beim Einlesen und 7 bei der Ausgabe statt 24 und 4. Welche Reihe stimmt, erklärt Google nicht. Eindeutig ist nur der Speichervorteil, der in beiden Tabellen gleich ausfällt. Beim Tempo liegt LiteRT-LM vorn, aber womöglich deutlich knapper, als die Haupttabelle suggeriert. Genau deshalb habe ich weiter unten selbst nachgemessen.

Bemerkenswert ist noch eine weitere Zahl: Für die Installation inklusive Sprachmodell-Unterstützung gibt Google rund 25 MB Download an, gegenüber etwa 1,44 GB bei Ollama. Das CLI ist nämlich nur eine dünne Hülle in Python und holt sich die Laufzeit-Bausteine erst bei Bedarf – Ollama bringt dagegen alle Beschleuniger-Treiber im Paket mit, egal ob das Zielgerät sie hat.

Aus TensorFlow Lite wurde LiteRT

Falls euch der Name nichts sagt, das Konzept aber bekannt vorkommt: LiteRT ist die umbenannte und weiterentwickelte Fassung von TensorFlow Lite. Wer also vor Jahren Objekterkennung auf dem Pi mit TensorFlow Lite gebaut hat, findet hier den direkten Nachfolger – die vertrauten .tflite-Modelldateien laufen weiterhin. Neu ist vor allem die Fähigkeit, auch große Sprachmodelle auszuführen.

Quellen

Alle Zahlen in diesem Abschnitt stammen aus den offiziellen Veröffentlichungen vom 11. bis 13. August 2026:

Das braucht ihr

Gemessen am 19. und 20. August 2026 mit LiteRT-LM 0.17 auf Raspberry Pi OS (64-bit), Installation zuletzt geprüft am 14. Oktober 2026 mit litert-cli 0.2.1. LiteRT entwickelt sich schnell, Details können sich also ändern.

Viel ist es nicht – LiteRT läuft ohne Zusatzhardware, ihr braucht also weder ein AI HAT noch einen Beschleuniger-Stick:

  • einen Raspberry Pi 5 – Google testet offiziell mit der 8-GB-Variante*, mein kompletter Testlauf lief aber auf dem deutlich günstigeren Pi 5 mit 4 GB*, und der reicht dafür aus
  • Raspberry Pi OS in der 64-Bit-Version – für 32-Bit-ARM gibt es keine LiteRT-Pakete, auf dem Pi muss also aarch64 laufen
  • mindestens 10 GB freien Speicherplatz – das Sprachmodell bringt 2,59 GB mit, und beim ersten Start kommt noch rund 1 GB Kompilierungs-Cache dazu; eine schnelle microSD-Karte* tut es, komfortabler läuft es von SSD
  • eine aktive Kühlung, zum Beispiel den offiziellen Active Cooler* – der Pi läuft während der Textgenerierung dauerhaft auf allen vier Kernen
  • ein kräftiges Netzteil – unter Volllast ist das offizielle 27-W-Netzteil* Pflicht, sonst drosselt der Pi
  • etwas Geduld beim ersten Start – wie lange der 2,59-GB-Download dauert, hängt allein an eurer Internetanbindung; mit einem Hugging-Face-Token geht es schneller
Mit * markierte Links sind Affiliate-Links, also Werbung. Kauft ihr darüber ein, erhalte ich eine Provision, der Preis bleibt für euch gleich. Als Amazon-Partner verdiene ich an qualifizierten Verkäufen. Mehr dazu

Eine NVMe-SSD* – am Pi 5 über den offiziellen M.2-HAT* angebunden – ist kein Muss, macht sich aber bemerkbar: Das Modell wird bei jedem Start neu von der Platte gelesen – 2,6 GB, bei denen jede Steigerung der Lesegeschwindigkeit direkt ankommt. Mein Testsystem lief von NVMe, dort meldete der Benchmark eine Init-Zeit von unter einer Sekunde; von der SD-Karte müsst ihr für den Modellstart mit deutlich mehr Geduld rechnen.

Bevor es losgeht, kurz gegenprüfen, ob euer System die Voraussetzungen erfüllt:

uname -m
cat /etc/os-release
free -h
df -h ~
Terminal auf dem Raspberry Pi 5: uname zeigt aarch64, dazu OS-Version, freier Arbeitsspeicher und freier Platz auf der NVMe-SSD
Alles im grünen Bereich: 64-Bit-System, 4 GB RAM und genug freier Platz

Bei uname -m muss aarch64 herauskommen. Steht dort armv7l, läuft noch ein 32-Bit-System – dann müsst ihr Raspberry Pi OS in der 64-Bit-Version neu aufspielen. Danach bringt ihr das System auf Stand:

sudo apt update
sudo apt full-upgrade -y

LiteRT auf dem Raspberry Pi installieren

LiteRT kommt nicht über apt, sondern als Python-Paket. Google empfiehlt dafür uv – einen sehr schnellen Paketmanager, der sich bei Bedarf auch gleich die passende Python-Version zieht.

Schritt 1: uv installieren

curl -LsSf https://astral.sh/uv/install.sh | sh
source $HOME/.local/bin/env
uv --version

Die zweite Zeile ist wichtiger, als sie aussieht: Sie macht uv in der laufenden Shell bekannt. Lasst ihr sie weg, begrüßt euch der Pi im nächsten Schritt mit „command not found“.

Installation des Paketmanagers uv per Skript im Terminal des Raspberry Pi, anschließend uv --version
uv ist installiert und nach dem source-Befehl in der Shell verfügbar

Schritt 2: Arbeitsverzeichnis und virtuelle Umgebung anlegen

mkdir -p ~/litert-test && cd ~/litert-test
uv venv --clear --python=3.13 --seed
source .venv/bin/activate
Virtuelle Python-Umgebung mit uv anlegen und aktivieren
Die virtuelle Umgebung ist aktiv – erkennbar am Präfix vor dem Prompt

Achtet darauf, das wirklich in einem eigenen Verzeichnis zu machen: --clear löscht eine vorhandene .venv im aktuellen Ordner kommentarlos. Wenn Python 3.13 auf eurem System fehlt, lädt uv es sich selbst herunter – ihr müsst also nichts am System-Python drehen.

Klappt alles, steht ab jetzt der Name der Umgebung in Klammern vor eurem Prompt. Und damit direkt zur häufigsten Stolperfalle: Nach jedem Neustart und in jedem neuen SSH-Fenster müsst ihr die Umgebung erneut aktivieren, sonst kennt die Shell den Befehl litert nicht:

source ~/litert-test/.venv/bin/activate

Schritt 3: Das LiteRT-CLI installieren

uv pip install litert-cli
litert --help

Ein kurzer Hinweis, weil sich die beiden offiziellen Seiten an dieser Stelle widersprechen: Die Schritt-für-Schritt-Anleitung von Raspberry Pi installiert litert-cli-nightly, also den täglich neu gebauten Entwicklungsstand. Der Übersichtsartikel nennt das stabile litert-cli. Ich empfehle inzwischen das stabile Paket: Seit Version 0.2 bringt es eine aktuelle Sprachmodell-Schicht mit (LiteRT-LM 0.17, dieselbe Generation, mit der meine Messwerte unten entstanden sind), und es ändert sich nicht über Nacht. Wer lieber der offiziellen Anleitung folgt, nimmt litert-cli-nightly – die Befehle in diesem Artikel funktionieren mit beiden. Nur mischen solltet ihr die beiden Linien nicht in derselben Umgebung.

Falls uv beim Auflösen der Abhängigkeiten hängen bleibt, hilft in der Regel ein explizit gesetzter Paket-Index:

export UV_INDEX_URL=https://pypi.org/simple

Die Grundinstallation ist bewusst klein: Das CLI ist nur eine schlanke Hülle und lädt die eigentlichen Laufzeit-Module erst nach, wenn ihr sie tatsächlich benutzt. Google gibt für das CLI inklusive Sprachmodell-Unterstützung rund 25 MB Download an. Ganz so knapp war es bei mir nicht: Allein das Sprachmodell-Modul, das beim ersten Aufruf nachkommt, wog gut 44 MB. Gegenüber den rund 1,44 GB von Ollama bleibt der Unterschied trotzdem gewaltig.

Gemma 4 lokal auf dem Raspberry Pi ausführen

Jetzt der spannende Teil. Sprachmodelle laufen bei LiteRT über eine eigene Schicht namens LiteRT-LM, die ihr über litert lm ansprecht. Ein Paket müsst ihr dafür nicht mehr von Hand nachinstallieren: Beim ersten Aufruf von litert lm meldet das CLI „Initializing ‚lm‘ components for the first time“ und holt die passenden Module selbst in eure virtuelle Umgebung. Das dauert ein paar Sekunden und passiert nur einmal.

Vorher: Braucht ihr einen Hugging-Face-Token?

Das Modell kommt von Hugging Face, und die offizielle Anleitung setzt dafür einen Zugangs-Token voraus, ohne das zu begründen. Ich habe es deshalb bewusst erst ohne probiert – und tatsächlich: Der Download läuft auch ohne Token, denn das Gemma-Repository in der LiteRT-Sammlung ist nicht zugangsbeschränkt. Ihr braucht also weder ein Konto noch die Zustimmung zu irgendwelchen Modellbedingungen, um loszulegen.

Ohne Anmeldung gelten bei Hugging Face allerdings strengere Rate-Limits und eine gedrosselte Übertragungsrate. Bei einer 2,59 GB großen Datei macht sich das bemerkbar – und wer mehrere Modelle ausprobieren will, merkt es umso deutlicher. Pflicht ist der Token nicht, empfehlenswert schon. Wenn ihr einen nutzen wollt, setzt ihn jetzt, vor dem ersten Download.

Und so bekommt ihr einen: Auf huggingface.co ein Konto anlegen, unter „Access Tokens“ einen neuen Token vom Typ Read erzeugen und in der Shell setzen:

export HF_TOKEN=euer_token_hier

Achtung, hier weiche ich bewusst von der offiziellen Anleitung ab: Die setzt HUGGING_FACE_HUB_TOKEN. Der Befehl litert lm liest aber nur HF_TOKEN (oder die Option --huggingface-token) – die alte Variable würde er beim Modell-Download schlicht übergehen. Kleiner Sicherheitshinweis am Rande: Der Token steht danach im Klartext in eurer Shell-History. Wer den Pi teilt oder Screenshots macht, sollte ihn danach wieder aus ~/.bash_history entfernen.

Der erste Aufruf

Tipp: Startet den Download in einer tmux-Sitzung

Der Modell-Download läuft eine Weile – und wenn währenddessen eure SSH-Verbindung abbricht, stirbt der Vorgang mit ihr. Mit tmux läuft er auf dem Pi weiter, egal was das Netz macht:

sudo apt install -y tmux
tmux new -s litert
source ~/litert-test/.venv/bin/activate

Die dritte Zeile nicht vergessen: Eine neue tmux-Sitzung ist wie ein neues SSH-Fenster, die virtuelle Umgebung muss darin erneut aktiviert werden. Bewusst rausgehen könnt ihr mit Strg+B, gefolgt von D. Nach dem nächsten Login holt ihr euch die Sitzung mit tmux attach -t litert zurück – samt allem, was inzwischen weitergelaufen ist.

Dann Modell aussuchen, Prompt dranhängen, fertig:

litert lm run \
  --from-huggingface-repo=litert-community/gemma-4-E2B-it-litert-lm \
  gemma-4-E2B-it.litertlm \
  --prompt="Was ist die Hauptstadt von Frankreich?"

Beim ersten Aufruf holt sich LiteRT die 2,59 GB große Modelldatei und legt sie unter ~/.litert-lm/cache/huggingface/ ab. Ab dem zweiten Aufruf meldet das CLI „Using cached model“ und startet ohne erneuten Download.

Terminal: litert lm run startet den Download von gemma-4-E2B-it.litertlm aus dem Hugging-Face-Repository
Der erste Aufruf lädt das Modell (Aufnahme vom August 2026 – die Installationszeile darüber braucht ihr heute nicht mehr)

Lasst ihr --prompt weg, landet ihr in einem interaktiven Chat. Das Modell bleibt dann zwischen den Fragen geladen, und ihr könnt frei drauflos tippen. Beendet wird der Chat mit Strg+C – die Tastenkürzel blendet das CLI beim Start ein.

Erste Antwort von Gemma 4 E2B im LiteRT-Terminal auf dem Raspberry Pi 5
Die erste lokale Antwort: Gemma 4 E2B über LiteRT-LM

Alternative: Modell in einen eigenen Ordner laden

Wollt ihr selbst bestimmen, wo die Modelldatei liegt – etwa auf einer zweiten Platte oder in eurem Projektordner –, nehmt den Schwesterbefehl litert download und startet das Modell anschließend über den lokalen Pfad. Wichtig ist dabei der Dateifilter --file:

litert download litert-community/gemma-4-E2B-it-litert-lm --file "gemma-4-E2B-it.litertlm" --output gemma
litert lm run ./gemma/gemma-4-E2B-it.litertlm --prompt="Was ist die Hauptstadt von Frankreich?"
Achtung: Ohne --file ladet ihr das ganze Repository

Lasst ihr den Dateifilter weg, holt sich litert download alle Varianten des Modells – zusammen rund 27 GB. Auf einer 32-GB-Karte ist das Ende der Fahnenstange dann schnell erreicht.

Der Grund dafür ist eigentlich praktisch: Google legt in dasselbe Repository neben der CPU-Fassung noch neun weitere Bauformen desselben Modells, jede für eine andere Hardware zugeschnitten (Stand November 2026).

DateiGrößeGedacht für
gemma-4-E2B-it.litertlm2,59 GBCPU – das ist die Datei für den Raspberry Pi
gemma-4-E2B-it-gpu.litertlm2,34 GBGPU-Ausführung
gemma-4-E2B-it-web.litertlm / .taskje rund 2 GBAusführung im Browser
…_Qualcomm_QCS82752,72 GBQualcomm-NPU (QCS8275)
…_NPU_Uncompiled2,61 GBNPU, nicht vorkompiliert
…_Google_Tensor_G5 / …_G63,21 / 3,45 GBNPU der Pixel-Reihe
…_intel_LNL / …_intel_PTLje rund 2,95 GBIntel-NPUs

Für den Pi ist davon nur die erste Zeile interessant. Alles andere ist Ballast – und genau deshalb gehört der --file-Filter in den Befehl. Der Aufruf mit --from-huggingface-repo aus dem vorigen Abschnitt macht das von sich aus richtig und holt nur die eine genannte Datei.

Egal auf welchem Weg: Beim allerersten Start solltet ihr etwas Geduld mitbringen. LiteRT kompiliert das Modell einmalig für euren Prozessor und legt das Ergebnis als .xnnpack_cache-Dateien neben die Modelldatei – bei mir gut 1 GB zusätzlich, der Ordner wuchs damit von 2,5 auf 3,5 GB. Dafür entfällt dieser Schritt bei allen folgenden Starts. Plant den Platz also gleich mit ein.

Wie viel Arbeitsspeicher braucht das Ganze?

Google nennt für Gemma 4 E2B einen Spitzenverbrauch von 1.432 MB – gemessen auf einem Pi 5 mit 8 GB. Genau das ist die Frage, die in keiner der offiziellen Ankündigungen beantwortet wird: Reicht auch weniger? Mein Testgerät ist der Pi 5 mit 4 GB – und die Antwort ist ein klares Ja. Während das Modell eine längere Antwort schrieb, lag der belegte Speicher bei 1.572 MB von 4.049, gut 2,4 GB blieben verfügbar. Am wichtigsten: Der Swap blieb während der gesamten Generierung bei null. Das System gerät also nicht ins Auslagern, wo es unbenutzbar langsam würde – Gemma 4 E2B und das 4-GB-Modell passen bequem zusammen.

Wollt ihr das selbst mitverfolgen, öffnet ein zweites SSH-Fenster und lasst euch den Speicher live anzeigen, während das Modell antwortet:

watch -n1 free -m
watch free -m zeigt 1.572 MB belegten Arbeitsspeicher und 0 MB Swap, während Gemma 4 E2B im LiteRT-Chat antwortet
Während Gemma antwortet: 1.572 MB belegt, Swap bei null (Pi 5 mit 4 GB)

Bricht der Lauf kommentarlos ab, hat der Kernel meist eingegriffen. Das seht ihr hier:

dmesg | grep -i oom

Tempo messen

Für Zahlen, die sich mit denen von Google vergleichen lassen, bringt das CLI einen eigenen Benchmark mit:

litert lm benchmark ~/.litert-lm/cache/huggingface/litert-community/gemma-4-E2B-it-litert-lm/gemma-4-E2B-it.litertlm

Habt ihr das Modell über litert download in einen eigenen Ordner geladen, setzt ihr stattdessen dessen Pfad ein, also etwa ./gemma/gemma-4-E2B-it.litertlm. Ihr bekommt zwei Werte: Prefill ist das Tempo, mit dem das Modell eure Eingabe verarbeitet, Decode das Tempo, mit dem es die Antwort schreibt. Der zweite Wert ist der, den ihr beim Zuschauen spürt. Meine Messwerte:

Benchmark gemma-4-E2B-it Raspberry Pi 5
Benchmark gemma-4-E2B-it Raspberry Pi 5

In Zahlen, damit ihr eure eigenen Läufe einordnen könnt (ein Messlauf nach Aufwärmphase, kein Median mehrerer Durchgänge, August 2026):

WertMeine Messung (Pi 5, 4 GB)Googles Referenz (Pi 5, 8 GB)
Prefill96,46 Token/s99 Token/s
Decode7,74 Token/s9 Token/s
Init-Zeit0,74 s–
Zeit bis zum ersten Token2,78 s–

Ein kleiner Haken beim direkten Vergleich: Der Benchmark rechnet in der Standardeinstellung mit 256 Prefill-Token, Google hat mit 1.024 gemessen. Die Werte sind also nicht exakt dasselbe Experiment – die Größenordnung passt aber. Bemerkenswert daran: Meine Zahlen stammen vom 4-GB-Modell und liegen trotzdem fast gleichauf mit Googles 8-GB-Referenz. Mehr Arbeitsspeicher macht das Modell nicht schneller, solange es bequem hineinpasst. Und knapp 8 Token pro Sekunde bei der Ausgabe heißt in der Praxis: Das Modell schreibt ungefähr so schnell, wie ihr lest. Für einen Chat völlig brauchbar, für lange Texte braucht ihr Geduld.

Und was taugt es im Alltag?

Benchmarks sind das eine – ich wollte wissen, wie sich das Modell bei einer echten Frage schlägt, und habe ihm ein typisches Maker-Problem gestellt: „Mein Raspberry Pi wird zu heiß. Schreib mir ein kurzes Bash-Skript, das die CPU-Temperatur ausliest und bei über 70 Grad warnt.“

Gemma 4 E2B beantwortet eine Alltagsfrage zur CPU-Temperatur im LiteRT-Chat
Sieht überzeugend aus – hält der Pi-Praxis aber nicht stand

Die Antwort sah auf den ersten Blick beeindruckend aus: sauber gegliedert, flüssiges Deutsch, komplett mit Installationsanleitung, Cron-Job und sogar einem Hinweis auf systemd. Auf einem beliebigen Linux-Rechner hätte ich anerkennend genickt. Nur: Auf einem Raspberry Pi funktioniert das gelieferte Skript nicht. Es setzt auf lm-sensors und sucht in der Ausgabe nach „Core“-Einträgen – das ist die Welt der Desktop-Prozessoren. Auf dem Pi heißt der Sensor cpu_thermal, ein „Core“-Eintrag existiert nicht, das Skript liefe also stets in seine eigene Fehlermeldung. Dazu kommt ein klassischer Bash-Schnitzer: Der Vergleich mit -gt kann nur Ganzzahlen, an einer Temperatur wie „45.6“ würde er scheitern.

Der Vollständigkeit halber, so geht es auf dem Pi wirklich – ohne Zusatzpakete:

#!/bin/bash
TEMP=$(( $(cat /sys/class/thermal/thermal_zone0/temp) / 1000 ))
if [ "$TEMP" -gt 70 ]; then
  echo "Warnung: CPU bei ${TEMP} Grad – Kühlung prüfen!"
fi

Das Fazit aus diesem kleinen Realitätstest: Gemma 4 E2B ist ein sprachlich starker Generalist, aber kein Gerätespezialist – bei einem Modell dieser Größenklasse völlig erwartbar. Für Alltagsaufgaben wie Zusammenfassen, Übersetzen oder Erklären ist es auf dem Pi erstaunlich brauchbar; bei technischen Details solltet ihr die Antworten gegenprüfen, so wie bei jedem Sprachmodell. Die Form ist perfekt, die Fakten sind es nicht immer.

Nicht nur Sprachmodelle: Bilder klassifizieren

LiteRT kann auch alles, wofür man früher TensorFlow Lite genommen hat. Ein Modell zur Bilderkennung ist in zwei Befehlen eingerichtet – als Testbild reicht ein beliebiges JPEG-Foto, das ihr zum Beispiel per scp als testbild.jpg in euer Home-Verzeichnis kopiert:

litert download litert-community/efficientnet_b1 --output efficientnet
litert run efficientnet/efficientnet_b1.tflite --input ~/testbild.jpg

Den --file-Filter von oben braucht ihr hier übrigens nicht: Das EfficientNet-Repository umfasst insgesamt nur rund 60 MB, da fällt es nicht ins Gewicht, wenn alle Varianten mitkommen. Als Antwort bekommt ihr die fünf wahrscheinlichsten Treffer mit Punktwert. Bei meinem Testbild – einer schlichten Kaffeetasse – sah das so aus: coffee mug mit deutlichem Abstand vorn (Score 7,84), gefolgt von cup, espresso, eggnog und teapot. Die Inferenz selbst dauerte 88 Millisekunden. Nebenbei verrät die Ausgabe auch die Eingabegröße: EfficientNet-B1 rechnet intern mit 240 × 240 Pixeln – euer Foto wird also stark verkleinert, feine Details spielen keine Rolle.

LiteRT Bildklassifikation mit EfficientNet-B1: CPU- und GPU-Lauf im Vergleich
Kaffeetasse erkannt: CPU- und GPU-Lauf im direkten Vergleich

Auf demselben Weg bekommt ihr Objekterkennung (YOLOX), Spracherkennung (Moonshine) oder Modelle für semantische Suche. Wer schauen will, was es sonst noch gibt: Die passenden Modelle liegen gesammelt in der LiteRT-Community auf Hugging Face.

GPU statt CPU – lohnt das auf dem Pi?

Seit August 2026 kann LiteRT auf dem Pi 5 auch die GPU nutzen. Grundlage ist der eingangs erwähnte experimentelle WebGPU-Support im Vulkan-Treiber V3DV. Aktiviert wird er über eine Umgebungsvariable – vorangestellt gilt sie nur für diesen einen Aufruf, ihr müsst hinterher also nichts zurücksetzen:

V3D_WEBGPU_OVERRIDE=1 litert run efficientnet/efficientnet_b1.tflite --input ~/testbild.jpg --gpu

Und jetzt die Erwartungsdämpfung, die Raspberry Pi in der offiziellen Anleitung gleich selbst mitliefert: Die GPU ist hier langsamer als die CPU. Das ist kein Fehler in eurem Setup, sondern der aktuelle Stand des experimentellen Treibers. In Googles Messreihe braucht EfficientNet-Lite0 auf der CPU 29,15 Millisekunden und auf der GPU 87,85 – also gut das Dreifache. Bei der Objekterkennung mit YOLO26n sind es 101,26 gegenüber 375,73 Millisekunden.

Der Sinn dahinter ist trotzdem einleuchtend: Der Pi 5 hat vier Kerne, und wenn ein Sprachmodell darauf rechnet, will man nicht gleichzeitig noch die Kamera-Auswertung darüberlegen. Genau so funktioniert Googles Roboter-Demo – Objekterkennung auf der GPU, Sprachmodell auf der CPU. Es geht also um Arbeitsteilung, nicht um mehr Tempo. Meine eigene Messung bestätigt das Bild: Dieselbe Klassifikation, die auf der CPU 88 Millisekunden braucht, dauert auf der GPU 170 – rund doppelt so lang. Die Ergebnisse sind dabei identisch, nur die Scores weichen in der zweiten Nachkommastelle ab. Eine Meldung beim GPU-Start dürft ihr ignorieren: Failed to load OpenCL library with dlopen ist nur ein Hinweis – LiteRT probiert erst OpenCL und landet dann wie vorgesehen beim Vulkan-Treiber.

Scheitert der Aufruf mit --gpu, gebt beide Ziele an – das CLI probiert dann der Reihe nach durch:

litert run efficientnet/efficientnet_b1.tflite --input ~/testbild.jpg --cpu --gpu

Wenn etwas klemmt

LiteRT ist ein junges Projekt, entsprechend ruckelt es an der einen oder anderen Stelle. Diese Handgriffe haben bei mir die meisten Probleme gelöst:

ProblemLösung
litert: command not foundVirtuelle Umgebung nicht aktiv – source ~/litert-test/.venv/bin/activate
uv bleibt beim Auflösen hängenexport UV_INDEX_URL=https://pypi.org/simple
Download trotz Token gedrosseltVariable heißt HF_TOKEN, nicht HUGGING_FACE_HUB_TOKEN – mit echo $HF_TOKEN prüfen
Unklare FehlermeldungLITERT_VERBOSE=1 voranstellen, dann wird das Log gesprächig
Failed to build flatbuffer modelKlingt nach defektem Modell, heißt aber meist nur: Die Datei fehlt oder ist leer – Pfad und Dateigröße prüfen (ls -lh)
Merkwürdige Zustände nach Abbrüchenlitert clean leert den Arbeits-Cache des CLI unter ~/.cache/litert-cli; heruntergeladene Sprachmodelle in ~/.litert-lm und eigene --output-Ordner bleiben dabei liegen

Noch eine kleine Irreführung: litert list meldet „No managed models found“ – obwohl das Modell längst auf der Karte liegt. Der Befehl kennt nur Modelle in LiteRTs eigenem verwaltetem Cache; was ihr mit --output in einen eigenen Ordner oder per litert lm run geladen habt, taucht dort nicht auf. Wenn ihr wissen wollt, wo eure Gigabyte geblieben sind, hilft stattdessen ein klassisches du -sh ~/.litert-lm ~/.cache ~/litert-test/gemma.

Allgemein gilt: Wenn euch das CLI mit einer Meldung ratlos zurücklässt, lest sie skeptisch und prüft erst die einfachen Dinge – aktive Umgebung, Pfad, Dateigröße. Eine Meldung, die nach Datenkorruption klingt, heißt hier oft nur, dass eine Datei fehlt.

LiteRT oder Ollama – wann lohnt sich was?

Wer auf dem Pi bisher lokale Sprachmodelle betrieben hat, tat das mit hoher Wahrscheinlichkeit über Ollama. Die Frage ist also berechtigt: umsteigen oder bleiben?

Der fairste Vergleich ist dasselbe Modell in derselben Quantisierung, denn Ollama führt Gemma 4 E2B ebenfalls in der QAT-Fassung (gemma4:e2b-it-qat). Auf dem Pi 5 mit 4 GB kommt dieser Vergleich allerdings gar nicht zustande – und das ist die eigentliche Erkenntnis:

$ ollama run gemma4:e2b-it-qat "Was ist die Hauptstadt von Frankreich?"
Error: 500 Internal Server Error: llama-server process has terminated: signal: killed

Ollama bekam dasselbe Modell auf dem 4-GB-Pi nicht zum Laufen (Stand meines Tests im August 2026). Der Kernel beendete den Ladevorgang, weil der Speicher nicht reichte – im Log steht es schwarz auf weiß, inklusive der angeforderten Menge:

$ dmesg | grep -i oom
Out of memory: Killed process 10193 (llama-server) total-vm:4506384kB, ...

Rund 4,5 GB wollte der Prozess haben – das deckt sich fast exakt mit Googles llama.cpp-Messung von 4.406 MB und ist schlicht mehr, als der 4-GB-Pi besitzt. Auch die 2 GB Swap retteten nichts: Der Ladevorgang wurde bei mir zweimal in Folge abgeräumt. Zur Einordnung in Zahlen:

Kriterium (Gemma 4 E2B QAT, Pi 5 mit 4 GB)LiteRT-LMOllama
Läuft das Modell?Ja – 7,74 Token/s AusgabeNein – vom Kernel beendet (OOM)
RAM beim Ausführen1.572 MB, Swap bleibt bei 0fordert ~4,5 GB an
Modell auf der Platte2,59 GB (+ ~1 GB Kompilier-Cache)4,3 GB
Laufzeitumgebung (Download laut Google)~25 MB~1,44 GB

Fair bleiben muss man trotzdem: Auf einem Pi 5 mit 8 GB läuft dasselbe Modell unter Ollama selbstverständlich – dort ist der Vergleich eine Tempo- und Komfortfrage. Und mit kleineren Modellen wie Gemma 3 1B hat Ollama auch auf dem 4-GB-Gerät kein Problem. Aber genau an der Stelle, an der es eng wird, zeigt sich der Unterschied der Architekturen: LiteRT-LM kommt mit den speichersparenden Eigenheiten von Gemma 4 E2B – den ausgelagerten Per-Layer-Embeddings – offenbar deutlich besser zurecht.

Unabhängig von den Messwerten unterscheiden sich die beiden aber vor allem im Charakter, und das ist für die Entscheidung wichtiger als ein paar Token pro Sekunde:

  • Ollama ist der bequeme Alltagsweg. Riesige Modellbibliothek, ein Befehl pro Modell, läuft als Dienst im Hintergrund und lässt sich mit Open WebUI in eine Oberfläche packen, die sich anfühlt wie ChatGPT. Für einen Pi, der ohnehin als kleiner Server läuft, ist das weiterhin die naheliegende Wahl.
  • LiteRT ist der schlanke Baukasten. Es glänzt dort, wo der Speicher knapp ist, wo ihr ein Modell fest in eine eigene Anwendung einbaut oder wo neben dem Sprachmodell noch Kamera- und Audioerkennung laufen sollen. Dass Bilderkennung, Spracherkennung und Sprachmodell alle über dieselbe Laufzeitumgebung laufen, spart im Projekt eine Menge Abhängigkeiten.

Die Grenze verschwimmt allerdings: LiteRT-LM bringt inzwischen mit litert-lm serve einen eigenen Server mit, der eine OpenAI-kompatible Schnittstelle anbietet. Damit ließen sich grundsätzlich auch Oberflächen wie Open WebUI anbinden.

Ein Wermutstropfen bleibt: Ollama hat die größere Modellauswahl. In der LiteRT-Sammlung auf Hugging Face liegen zwar neben Gemma auch Qwen, Phi, SmolLM und sogar ein destilliertes DeepSeek-R1, aber die Modelle müssen erst ins LiteRT-Format überführt werden. Was dort nicht liegt, müsst ihr selbst konvertieren.

Was als Nächstes kommt

Der für Bastler spannendste Satz steht bei Google und Raspberry Pi ganz am Ende: LiteRT und die Gemma-Modelle sollen die Hailo-Beschleuniger unterstützen. Damit ließe sich die Inferenz auf das AI HAT+ 2 mit Hailo-10H auslagern – über dieselben Befehle, die ihr oben gelernt habt. Ein Datum gibt es dafür auch im Oktober 2026 noch nicht, getestet werden kann es entsprechend noch nicht. Sobald es soweit ist, reiche ich die Messwerte hier nach.

Wer sehen will, wozu das Ganze taugt, wenn man es zu Ende denkt: Google hat mit dem Gemma Translator ein Beispielprojekt veröffentlicht, das aus einem Pi 5 einen Dolmetscher macht, der komplett offline arbeitet. Und die Roboter-Demo, mit der die Ankündigung beworben wurde, verteilt die Arbeit sauber: Objekterkennung auf der GPU, Spracherkennung und Sprachmodell auf der CPU. Genau für solche Aufteilungen ist LiteRT gebaut – wer auf einem Pi mit 8 GB nur einen Chatbot will, ist mit Ollama schneller am Ziel.

Fazit

LiteRT ist die erste Laufzeitumgebung für lokale Sprachmodelle, die Raspberry Pi selbst aktiv empfiehlt – und das merkt man ihr an. Die Installation ist in zehn Minuten erledigt, der Speicherhunger fällt deutlich geringer aus als bei den bekannten Alternativen, und mit derselben Werkzeugkiste laufen auch Bild- und Spracherkennung. Seit dem Start im August ist das CLI zudem spürbar gereift: Die Sprachmodell-Teile installieren sich selbst, und heruntergeladene Modelle bleiben im Cache.

Ehrlich bleiben muss man trotzdem: Die GPU-Unterstützung ist experimentell und aktuell langsamer als die CPU, die Modellauswahl ist überschaubar, und an manchen Stellen ruckelt das Werkzeug noch. Wer auf einem Pi mit 8 GB einfach einen zuverlässigen lokalen Chatbot will, fährt mit Ollama weiterhin entspannter.

Interessant wird LiteRT für alle, die etwas bauen statt nur zu chatten: für Projekte mit knappem Speicher, für Kombinationen aus Kamera, Mikrofon und Sprachmodell – und spätestens dann, wenn die angekündigte Hailo-Unterstützung kommt und das AI HAT die Rechenarbeit übernimmt. Mein Schlussurteil nach zwei Testtagen: LiteRT fühlt sich stellenweise noch nach Baustelle an – aber dass mein günstigster Pi 5 ein Modell ausführt, an dem der etablierte Platzhirsch scheitert, hat mich dann doch beeindruckt.

Viel Spaß beim Ausprobieren – und schreibt gern in die Kommentare, welches Modell bei euch am besten läuft.

Ist LiteRT dasselbe wie TensorFlow Lite?

Im Kern ja. LiteRT ist der umbenannte und weiterentwickelte Nachfolger von TensorFlow Lite. Bestehende .tflite-Modelle laufen weiterhin, dazugekommen ist vor allem die Unterstützung für große Sprachmodelle über die Schicht LiteRT-LM.

Wie viel Arbeitsspeicher braucht Gemma 4 E2B auf dem Raspberry Pi?

Google gibt einen Spitzenwert von 1.432 MB an, gemessen auf einem Raspberry Pi 5 mit 8 GB RAM. Meine eigene Messung bestätigt das: Auf dem Pi 5 mit 4 GB waren während der Textgenerierung 1.572 MB belegt, der Swap blieb bei null – das Modell läuft dort ohne Einschränkung. Zum Vergleich: llama.cpp braucht für dasselbe Modell 4.406 MB.

Läuft LiteRT auch auf einem Raspberry Pi 4?

Offiziell optimiert und getestet ist ausschließlich der Raspberry Pi 5, Messwerte für den Pi 4 gibt es weder von Google noch von mir. Voraussetzung wäre in jedem Fall ein 64-Bit-System, denn für 32-Bit-ARM gibt es keine LiteRT-Pakete.

Ist LiteRT schneller als Ollama?

Auf dem Pi 5 mit 4 GB stellt sich die Frage nicht: Dort lief Gemma 4 E2B in meinem Test nur unter LiteRT (7,74 Token/s Ausgabe) – Ollama wurde mit demselben Modell vom Kernel wegen Speichermangels beendet. Für den 8-GB-Pi sieht Google LiteRT-LM ebenfalls vorn, bei einem Drittel des Speicherbedarfs. Wie groß der Tempovorsprung ist, bleibt offen: Googles Haupttabelle nennt für llama.cpp 24 und 4 Token pro Sekunde, der Anhang 58 und 7 – gegenüber 99 und 9 bei LiteRT-LM.

Brauche ich für LiteRT ein AI HAT oder einen anderen Beschleuniger?

Nein. LiteRT rechnet auf der CPU des Raspberry Pi, optional auch auf der eingebauten GPU. Unterstützung für die Hailo-Beschleuniger im AI HAT+ und AI HAT+ 2 ist angekündigt, aber noch nicht verfügbar.

Funktioniert LiteRT ohne Internetverbindung?

Ja. Einmalig muss das Modell heruntergeladen werden – bei Gemma 4 E2B sind das 2,59 GB. Danach läuft alles lokal auf dem Gerät, es werden keine Daten an einen Server geschickt.

Ähnliche Beiträge