llm-checker: a utility that shows which LLMs your hardware can run

One of the most frequent questions that enthusiasts of locally running language models ask themselves sounds deceptively simple: will my hardware handle it? Until now, the answer had to be pieced together from scattered benchmarks, Reddit discussions, and trial-and-error experiments. A new open-source tool llm-checker attempts to answer this question with a single terminal command.

llm-checker is a CLI utility that scans a computer's hardware configuration and provides a concrete verdict: which language models from the Ollama ecosystem you can run, at what speed, and with what quality. The tool analyzes three key components — GPU, RAM, and CPU — and based on this data produces a personalized report for more than 35 models, from compact single-parameter models to impressive 32-billion-parameter ones.

To understand why this matters, it's worth recalling the context. Over the past two years, the movement to run large language models locally has transformed from a marginal hobby into a full-fledged direction. Ollama has become the de facto standard for those who want to run an LLM on their own computer without cloud subscriptions and without sending data to third-party servers.

Llama, Mistral, Gemma, Phi, DeepSeek, Qwen — the number of available models grows every month, and each of them has its own hardware requirements. The problem is that these requirements are nowhere systematized in relation to specific configurations. A person with an RTX 3060 with 12 gigabytes of video memory and 32 gigabytes of RAM is forced to figure out themselves whether they can run Llama 3.

1 with 8 billion parameters in Q4 quantization, or should not even try.

This is exactly the gap between the abundance of models and the opacity of hardware requirements that llm-checker closes. The utility works in the most straightforward way: you run a command, it queries the system, compares the characteristics with an internal knowledge base about models, and provides the result. Each model is evaluated on three axes — compatibility (will it run at all), speed (will token generation be comfortable), and quality (will you have to sacrifice accuracy for performance). These are not abstract scores, but practically useful information that saves hours of experimentation.

Particular attention deserves the approach to curating the list of models. The authors deliberately refused to automatically parse the entire Ollama catalog and instead moderate the list manually. This is a principled decision: the Ollama catalog contains hundreds of models of varying quality, including outdated, experimental, and frankly useless ones. Manual curation means that users receive recommendations only for verified, current models that are actually worth running. In a world where the number of open LLMs doubles every few months, such a filter is not a limitation, but an advantage.

Technically, the tool solves a non-trivial task. The performance of a local LLM depends on many factors: the amount of video memory determines whether the model will fit entirely on the GPU; RAM speed affects the offloading of layers that didn't fit in VRAM; CPU architecture is important for models that run in CPU mode. Quantization adds another dimension — the same model in Q8 format might not fit in memory, but in Q4 works, albeit with noticeable quality loss. llm-checker takes on all these calculations and translates them into understandable recommendations.

In a broader context, the emergence of such tools signals the maturation of the local AI ecosystem. When technology moves beyond the circle of developers and enthusiasts, it needs bridges between complexity and simplicity. llm-checker is one such bridge. It doesn't do anything revolutionary from a technological standpoint, but solves a real user problem that has been ignored so far.

Of course, the tool has obvious limitations. Binding to Ollama means that users of llama.cpp, vLLM, or other backends are left out. Manual moderation of the model list is simultaneously a strength and a weakness, because relevance depends on the activity of maintainers. Actual performance will always differ from predictions, because it is affected by dozens of variables that are impossible to account for remotely — from GPU temperature under load to background processes on the system.

Nevertheless, llm-checker points in the right direction. As local LLM execution becomes mainstream — and all trends point to this — the need for simple diagnostic and recommendation tools will only grow. Today it's a CLI utility for advanced users. Tomorrow, similar functionality could well become an embedded part of Ollama itself or its analogs. Because the best way to attract users to local AI is to remove the barrier of uncertainty and provide an honest answer to a simple question: what exactly can I run right now.