Das Experimentieren mit lokalen KI-Modellen macht Spaß. Bis es das nicht mehr tut.
Du lädst ein Modell herunter, wartest zehn Minuten, startest es, und dann: Ollama friert ein, der RAM ist voll, oder die Inferenz kriecht mit 0,3 Tokens pro Sekunde dahin. Also probierst du das nächste. Und das übernächste. Irgendwann hast du drei Stunden damit verbracht herauszufinden, was dein System eigentlich schluckt, und weißt immer noch nicht, ob Qwen3-14B auf deiner RTX 4070 flüssig läuft.
Das ist das Problem, das llmfit löst. Und zwar elegant.
Was ist llmfit?
llmfit ist ein Terminal-Tool, das Hunderte von LLM-Modellen gegen deine Systemressourcen matched: RAM, CPU und GPU. Es erkennt deine Hardware, bewertet jedes Modell entlang mehrerer Dimensionen und sagt dir, welche Modelle auf deinem Rechner tatsächlich gut laufen werden.
Das klingt einfacher als es ist. Denn hinter „gut laufen“ steckt einiges an Logik.
Das Tool liefert ein interaktives TUI (Terminal User Interface) als Standard sowie einen klassischen CLI-Modus. Es unterstützt Multi-GPU-Setups, MoE-Architekturen (Mixture of Experts), dynamische Quantisierungsauswahl, Geschwindigkeitsschätzungen und lokale Runtime-Provider wie Ollama, llama.cpp, MLX, Docker Model Runner und LM Studio.
Auf GitHub hat das Projekt mittlerweile über 26.000 Stars. Das sagt genug.
Wie funktioniert das unter der Haube?
Das ist der Teil, der mich am meisten beeindruckt. Vier Schritte, die zusammenspielen:
Hardware-Erkennung
llmfit liest RAM und CPU-Kerne via sysinfo aus und sucht nach GPUs: NVIDIA über nvidia-smi mit Aggregation über mehrere GPUs, AMD über rocm-smi, Intel Arc via sysfs, Apple Silicon über system_profiler (wobei VRAM gleich System-RAM ist, da Unified Memory), und Ascend-NPUs über npu-smi. Zusätzlich identifiziert das Tool automatisch das Beschleunigungsbackend, also CUDA, Metal, ROCm, SYCL oder CPU, für die spätere Geschwindigkeitsschätzung.
Kurz gesagt: llmfit weiß, was in deinem Rechner steckt, bevor es auch nur ein Modell anschaut.
Die Modelldatenbank
Hunderte Modelle, bezogen von der HuggingFace-API, sind in data/hf_models.json gespeichert und beim Kompilieren direkt ins Binary eingebettet. Memory-Anforderungen werden aus Parameteranzahlen über eine Quantisierungshierarchie von Q8_0 bis Q2_K berechnet.
Besonders clever: der Umgang mit MoE-Modellen.
Modelle mit Mixture-of-Experts-Architektur wie Mixtral oder DeepSeek-V2/V3 werden automatisch erkannt. Da pro Token nur eine Teilmenge der Experten aktiv ist, liegt der tatsächliche VRAM-Bedarf deutlich unter dem, was die Gesamtparameterzahl suggeriert. Mixtral 8x7B hat zwar 46,7 Milliarden Parameter insgesamt, aktiviert aber nur rund 12,9 Milliarden pro Token, was den VRAM-Bedarf von 23,9 GB auf rund 6,6 GB mit Expert-Offloading senkt.
Das ist genau das Wissen, das man als Laie nicht hat, wenn man ein Modell testet.
Dynamische Quantisierung
Statt eine feste Quantisierung vorauszusetzen, versucht llmfit die beste Qualitätsstufe, die auf deine Hardware passt. Es durchläuft eine Hierarchie von Q8_0 (beste Qualität) bis Q2_K (stärkste Komprimierung) und wählt die höchste Qualität, die noch in den verfügbaren Speicher passt. Wenn nichts bei vollem Kontext passt, wird der Versuch mit halbem Kontext wiederholt.
Kein Rätselraten mehr. Das Tool entscheidet das für dich.
Mehrdimensionales Scoring
Jedes Modell wird entlang von vier Dimensionen bewertet: Quality (Parameterzahl, Modell-Reputation, Quantisierungspenalty, Task-Ausrichtung), Speed (geschätzte Tokens pro Sekunde basierend auf Backend, Parametern und Quantisierung), Fit (Memory-Auslastungseffizienz, Idealbereich 50 bis 80 Prozent des verfügbaren Speichers) und Context (Kontextfenstergröße vs. Use-Case-Ziel).
Die Gewichtung dieser Dimensionen variiert je nach Use-Case-Kategorie. Chat gewichtet Speed höher (0,35), während Reasoning Quality höher wertet (0,55). Modelle, die nicht lauffähig sind, landen immer am Ende der Liste.
Das ist nicht einfach ein Lookup-Table. Das ist echtes Hardware-Matching.
Die Benutzeroberfläche
Wer llmfit ohne Argumente startet, landet im TUI. Und das TUI ist gut.
Oben zeigt es deine Systemspezifikationen, also CPU, RAM, GPU-Name, VRAM und Backend. Die Modelle sind in einer scrollbaren Tabelle nach Composite Score sortiert. Jede Zeile zeigt Score, geschätzte Tokens/Sekunde, beste Quantisierung für deine Hardware, Run Mode, Speicherauslastung und Use-Case-Kategorie.
Ein paar Shortcuts, die man schnell verinnerlicht:
/: Suche nach Modellname, Provider, Parametergröße oder Use Casef: Fit-Filter wechseln zwischen All, Runnable, Perfect, Good, Marginals: Sortierung wechselnp: Plan Mode für ein Modell öffnen (Hardware-Planung)b: Community Leaderboard öffnend: Modell direkt herunterladenS: Hardware simulieren
Ich wollte das eigentlich kurz halten, aber der Plan-Mode verdient eine Erwähnung.
Plan Mode dreht die normale Fit-Analyse um: statt „was passt auf meine Hardware?“ schätzt er „welche Hardware brauche ich für dieses Modell?“. Er zeigt Mindest- und empfohlene VRAM/RAM/CPU-Werte, mögliche Run-Pfade (GPU, CPU-Offload, CPU-only) und Upgrade-Deltas um bessere Fit-Level zu erreichen.
Das ist praktisch, wenn du überlegst, ob sich ein GPU-Upgrade lohnt.
Community Leaderboard: Theorie trifft Praxis
Das ist das Feature, das llmfit von reinen Schätztools unterscheidet.
Im Community Leaderboard sieht man reale Performance-Daten anderer User mit derselben Hardware: tatsächlich gemessene Tokens pro Sekunde, Time-to-First-Token und Peak-VRAM-Auslastung. Die Daten kommen von localmaxxing.com, einer Community-Benchmark-Datenbank. llmfit erkennt dein GPU-Modell, den VRAM-Tier, die Apple-Silicon-Chipfamilie und das OS und fragt passende Ergebnisse ab.
Mit H öffnet sich ein Hardware-Picker mit 27 populären GPUs und Chips, von der RTX 5090 bis CPU-only, plus Apple Silicon M1 bis M4, AMD RX/MI-Serie und NVIDIA-Datacenter-Karten. So sieht man Benchmarks für Hardware, die man gerade nicht hat, bevor man sie kauft.
Das ist kein Marketing-Feature. Das ist ehrliche Hilfe.
Installation: Schritt für Schritt
Jetzt kommt der praktische Teil. Die gute Nachricht: llmfit ist in Rust geschrieben, was bedeutet, dass du ein einzelnes Binary bekommst, das einfach funktioniert.
macOS (empfohlen: Homebrew)
brew install AlexsJones/llmfit/llmfit
Alternativ aus dem homebrew-core, wenn du aus Source bauen willst:
brew install llmfit
Windows (Scoop)
Powershell öffnen:
scoop install llmfitFalls Scoop noch nicht installiert ist, findest du die Anleitung unter scoop.sh.
macOS / Linux: Quick Install
curl -fsSL https://llmfit.axjns.dev/install.sh | sh
Das lädt das neueste Release-Binary von GitHub und installiert es nach /usr/local/bin, oder nach ~/.local/bin wenn kein sudo verfügbar ist. Ohne sudo geht das so:
curl -fsSL https://llmfit.axjns.dev/install.sh | sh -s -- --local
Via Python (uv oder pip)
v tool install -U llmfit
Oder einmalig ausprobieren ohne Installation:
uvx llmfit
Docker / Podman
docker run ghcr.io/alexsjones/llmfit
Das gibt JSON aus llmfit recommend aus, das dann mit jq weiterverarbeitet werden kann:
podman run ghcr.io/alexsjones/llmfit recommend --use-case coding | jq '.models[].name'Aus dem Source (Rust erforderlich)
git clone https://github.com/AlexsJones/llmfit.git
cd llmfit
cargo build --release
# Binary liegt unter target/release/llmfit
Erste Schritte nach der Installation
Nach der Installation startest du llmfit einfach:
llmfitDas TUI öffnet sich, erkennt deine Hardware automatisch und zeigt dir sofort die passenden Modelle an. Nichts konfigurieren, nichts anpassen.
Wenn du lieber auf der Kommandozeile bleibst:
# Tabelle aller Modelle nach Fit sortiert
llmfit --cli
# Nur perfekt passende Modelle, Top 5
llmfit fit --perfect -n 5
# Hardware-Specs anzeigen
llmfit system
# Modell suchen
llmfit search "llama 8b"
# Top 5 Empfehlungen als JSON (für Skripte oder Automatisierung)
llmfit recommend --json --limit 5
# Gefiltert nach Use Case
llmfit recommend --json --use-case coding --limit 3Hardware-Override, wenn die Autoerkennung spinnt:
# GPU-VRAM manuell setzen
llmfit --memory=24G
# System-RAM überschreiben
llmfit --ram=64G
# Ziel-Hardware simulieren
llmfit --memory=24G --ram=64G --cpu-cores=8 fit
Das ist der Fall, wenn nvidia-smi auf Linux manchmal falsche Werte zurückgibt, oder wenn du auf einer VM arbeitest.
Ollama-Integration: direkt im Tool herunterladen
llmfit erkennt automatisch, ob Ollama läuft, und zeigt installierte Modelle mit einem grünen Haken in der Inst-Spalte an.
Beim Start fragt llmfit GET /api/tags ab, um installierte Ollama-Modelle zu listen. Wenn du im TUI d drückst, sendet llmfit POST /api/pull an Ollama, um das Modell zu laden. Die Zeile zeigt einen animierten Fortschrittsindikator in Echtzeit. Wenn Ollama nicht läuft, werden Ollama-spezifische Operationen einfach übersprungen.
Für Ollama auf einem anderen Rechner:
OLLAMA_HOST="http://192.168.1.100:11434" llmfitWas ich daran schätze
Ich arbeite seit Monaten intensiv mit lokalen Modellen. VINCI, mein KI-Assistent-Projekt, läuft mit Gemini über die API, aber für Offline-Szenarien und Tests brauche ich immer wieder lokale Inferenz.
Das Problem war nie die Installation von Ollama oder llama.cpp. Das Problem war das Trial-and-Error: welche Modellgröße passt, welche Quantisierung macht Sinn, wo ist der Sweet Spot zwischen Qualität und Geschwindigkeit auf meiner Hardware.
llmfit beantwortet das in Sekunden. Das ist kein dramatischer Fortschritt, der die Welt verändert. Aber es ist ein konkretes Werkzeug, das eine konkrete Frustration löst. Und das ist genau das, was gutes Open-Source-Tooling ausmacht.
26.000 Stars auf GitHub in kurzer Zeit sprechen für sich.
Link zum Repo
Das Projekt findest du auf GitHub: https://github.com/AlexsJones/llmfit
