Find the local LLM that actually runs and performs best on your hardware. Ranked by real, recency-aware benchmarks, not parameter count. One command, run it instantly.
5.7k
Stars
301
Forks
16
Open issues
23
Contributors
AI Analysis
whichllm is a CLI tool that automatically detects your hardware (GPU, CPU, RAM) and recommends the best local LLM models from HuggingFace that will actually run on your system, ranked by real benchmarks rather than parameter count. It serves developers and researchers who want to run inference locally without guessing whether a model will fit or perform acceptably on their specific hardware. This tool is specialized for the local LLM inference niche and is not a general-purpose development ut...
Inferred from signals mentioned in the README (tests, CI, type safety) — not a review of the actual code.
AI's overall editorial judgment — not an average of the bars above, can weigh other factors too.
One-command tool ranks local LLMs by benchmark quality and hardware fit, not just parameter count
whichllm solves a real friction point for local LLM users: knowing not just which models technically fit in VRAM, but which ones perform best given real benchmarks and hardware constraints. It auto-detects GPU/CPU/RAM, fetches live HuggingFace model data, applies recency-weighted benchmark scores from multiple leaderboards, and outputs a ranked list with speed estimates. Built for developers, researchers, and hobbyists running local inference who want an evidence-based starting point rather than guessing by model size. Secondary features include hardware simulation, one-command chat, and JSON output for scripting.
Created in March 2026, the project is young (~4 months old as of evaluation date). It appears to have grown rapidly from a personal utility into a more structured tool, now available via PyPI, Homebrew, and uvx, suggesting the author responded to early adoption with packaging investment.
5,195 stars in roughly 4 months indicates a viral moment, likely from social sharing on X/Twitter, Hacker News, or Reddit communities focused on local AI. The 239 stars in the last 7 days suggests sustained but decelerating organic growth rather than a single spike. Trendshift badge presence confirms it appeared on trending lists. The problem it solves — hardware-aware LLM selection — is timely given the proliferation of local LLM options in 2025-2026.
No documented enterprise or production deployments found in the README. Adoption appears to be primarily individual developers and local AI enthusiasts. PyPI download counts are not cited. The 279 forks and 5,195 stars suggest meaningful community engagement, but verifiable production usage at scale is not documented. Adoption not verified beyond hobbyist/developer use.
Likely a Python CLI application structured around three concerns: hardware detection (NVIDIA/AMD/Intel/Apple Silicon via system APIs), HuggingFace API queries with cached fallbacks for offline use, and a scoring engine that merges benchmark data with hardware estimates. Architecture-aware VRAM modeling (weights + KV cache + activation + overhead) and speed estimation (bandwidth-bound model with per-quant and backend factors) are described in detail in the README, suggesting these are real implemented features rather than aspirational claims. Command dispatch appears to use subcommands (run, plan, upgrade, snippet). Offline fallback via 'curated frozen' data implies bundled benchmark snapshots.
A passing CI badge (GitHub Actions test.yml) is present in the README, indicating automated tests exist and are currently green. Coverage level and test breadth are not documented in the README.
Last push was 2026-06-23, one day before evaluation date, indicating very active maintenance. The project is 4 months old and has received consistent updates. MIT license, PyPI publication, Homebrew tap, and a sponsor link suggest the author is treating this as a serious ongoing project rather than a one-off script. No evidence of stagnation.
ADOPT IF: you regularly evaluate new local LLMs and want a fast hardware-aware starting point rather than manually cross-referencing leaderboards; the benchmark aggregation and recency-weighting logic works as described. AVOID IF: you need auditable, fully transparent benchmark sourcing for professional decisions, or if your primary concern is maximum VRAM utilization rather than benchmark-quality tradeoffs — llmfit may serve that narrower need more robustly. MONITOR IF: you are interested but uncertain whether the benchmark data quality holds up over time as new models release rapidly; the project's value depends entirely on keeping its scoring data current and accurate.
Independent dimensions
Mainstream potential
5/10
Technical importance
7/10
Adoption evidence
3/10
- Benchmark data staleness: the tool's core value depends on continuously tracking multiple leaderboards (LiveBench, Artificial Analysis, Aider, Chatbot Arena, etc.). If the author cannot sustain this curation effort, recommendations will quietly degrade in quality.
- Single-maintainer bus factor: the project appears to be maintained primarily by one person (Andyyyy64). No evidence of a broader contributor team, which creates sustainability risk for a tool requiring ongoing data maintenance.
- Benchmark gaming and self-reported scores: the README acknowledges 'self-reported' scores exist and are discounted, but the actual filtering logic cannot be verified from README alone. Users may over-trust rankings that incorporate low-quality benchmark data.
- Competition from llmfit: the dominant tool in this space (28k stars) could add quality-ranking features, reducing whichllm's differentiation. The gap between 5k and 28k stars suggests whichllm has not yet displaced the established tool.
- HuggingFace API dependency: live data fetching from HuggingFace means rate limiting, API changes, or HuggingFace policy shifts could degrade the tool's primary data source, with frozen fallbacks potentially becoming stale.
whichllm will likely stabilize as a well-regarded utility in the local LLM hobbyist community, potentially reaching 10-15k stars over the next year. Mainstream dominance is unlikely given llmfit's head start, but the benchmark-quality angle gives it a defensible niche.
Newsletter
Get analyses like this every Monday
Free weekly digest of the most interesting open-source discoveries.
Languages
Information
- Language
- Python
- License
- MIT
- Last updated
- 2d ago
- Created
- 4mo ago
- Analyzed with
- anthropic/claude-haiku-4-5
Stars over time
Contributors over time
Top 100 contributors only — repos with more will plateau at 100.
Open issues
Results not good for my GPU
Retune AA index normalization and refresh snapshot for AA's reworked index
Benchmark pipeline fails on macOS: AA scraper broken, HF 429s, community GGUF ID mismatch
A3000 Laptop 6GB: Recommendations very poor
Feature Request: Multi-GPU simulation via --gpu flag (heterogeneous setups)
Top contributors
Similar repos
Troyanovsky/Local-LLM-Comparison-Colab-UI
This repository provides a collection of Google Colab notebooks for hands-on...
| Repository | Stars | Week Δ | Language | Score | Updated |
|---|---|---|---|---|---|
|
Andyyyy64/whichllm
this
|
5.7k | +203 | Python | 8/10 | 2d ago |
 AlexsJones/llmfit
|
29.3k | — | Rust | 8/10 | 13 min ago |
 jamesob/local-llm
|
1.3k | — | Shell | 8/10 | 2d ago |
 signerless/llm-checker
|
2.8k | — | JavaScript | 8/10 | 4d ago |
|
Troyanovsky/Local-LLM-Comparison-Colab-UI
|
1.1k | — | Jupyter Notebook | 6/10 | 6mo ago |
 vllm-project/guidellm
|
1.4k | — | Python | 7/10 | 10h ago |
llmfit (28,532 stars, Rust) is the dominant tool in hardware-fit checking for local LLMs, with roughly 5x the stars. Written in Rust, it likely prioritizes speed and portability. whichllm differentiates on benchmark-quality ranking rather than pure fit detection — a meaningful distinction if the benchmark scoring is accurate. llmfit's much larger adoption suggests it may cover the 'what fits' use case more thoroughly, but whichllm claims to solve the 'what fits AND performs best' question.
airllm (21,267 stars) focuses on running large models with limited VRAM via layer-by-layer inference — a different problem. It solves 'how to run a model that doesn't fit' rather than 'which model to choose.' Not a direct competitor, but serves overlapping users who are constrained by hardware.
vllm (83,661 stars) is a high-throughput inference engine, not a recommendation tool. These are complementary: whichllm could help users decide which model to run on vllm. No direct competition.
guidellm (1,298 stars) focuses on benchmarking and evaluation of LLMs in deployment contexts. It measures actual performance rather than recommending from pre-existing benchmarks. More of a post-selection evaluation tool than a pre-selection recommender — adjacent but not identical problem.
The status quo for most users is manual cross-referencing of multiple leaderboards against their hardware specs. whichllm's core value proposition is automating this workflow. The risk is that benchmark aggregation quality must be maintained continuously to remain trustworthy — something a static website can do more transparently.
