llmrun.dev offers a no-install answer to a common local-AI setup problem: which open LLMs will fit on your computer, and which should generate text at a useful speed? The site lets you detect your hardware in the browser or choose it manually, then compare models using memory requirements, predicted generation speed and its own composite ranking.
The privacy promise is equally direct. Beside the detection button, the site says: “Detection runs in your browser, nothing is uploaded.”
The useful detail is in llmrun’s methodology. Its recommendations account for model weights, conversation memory and runtime overhead. Its speed estimates describe one particular workload: generating text for one user. Those conditions make the results useful for shortlisting, but they also explain why a compatibility verdict cannot guarantee that every advertised context length will fit.
Start With Your Hardware, Then Compare Models
The homepage offers two entry points: Detect my hardware and Choose hardware. Automatic detection provides the quick route; manual selection lets you check a specific device or compare a potential upgrade.
A practical workflow is:
- Detect or select your device. Check that the resulting hardware selection matches the machine you intend to use.
- Browse models that fit its memory. The site also provides memory tiers including 8, 12, 16, 24 and 48 GB.
- Compare predicted speed alongside ranking. A higher-ranked model may generate text more slowly.
- Check the intended task. The catalog includes categories for coding, reasoning, vision, tool use, long context and small models.
The homepage illustrates the output with these sample verdicts:
| Hardware | Site’s recommended model | Predicted generation speed |
|---|---|---|
| RTX 3060, 12 GB | Qwen3.5 9B | About 37 tokens/second |
| RTX 4090, 24 GB | Qwen3.8 27B | About 38 tokens/second |
| MacBook Pro M4 Max, 48 GB | Qwen3.8 27B | About 22 tokens/second |
These are llmrun’s published predictions, not independent measurements. This article analyzes the site and its documentation; no hardware detection or performance benchmarks were independently tested.
The distinction between compatibility and execution matters. Checking a model here does not install it or start a local chat session. Running it remains a separate step in an inference application, such as Ollama, LM Studio or a llama.cpp-based setup.
Memory Fit Includes More Than the Model File
llmrun’s memory calculation combines three components:
- Model weights: the learned parameters, with storage determined partly by their numerical precision.
- KV cache: working memory used to retain attention information from the conversation.
- Runtime overhead: an allowance of approximately 0.3 GB for the inference framework.
Quantization reduces the precision used to store weights, making a model smaller at a potential cost to output quality. The documentation gives a roughly 7-billion-parameter model as an example: around 13 GB at FP16 precision, versus roughly 4 GB in a Q4_K_M quantization.
That is why a model’s parameter count alone cannot answer whether it fits. The quantized version and the conversation length both matter.
llmrun says it calculates cache requirements from architecture details when available, including the number of layers and key-value heads. When those details are unavailable, it falls back to a simpler 10% overhead estimate. It also says observed memory figures from Ollama or llama.cpp take priority over estimates when available.
I’d give more weight to a memory result tied to an observed configuration. An architectural estimate is useful, but a measured figure has fewer assumptions about how the runtime allocates memory.
A Long Context Label Is Not a Fit Guarantee
The most consequential detail is that llmrun reserves memory for a 16K-token context in its fit checks and model lists. Meanwhile, individual rows can advertise model context limits such as 256K tokens. Those numbers describe different things: the fit calculation’s working allowance and the model’s listed context capability. The methodology explains this distinction.
The practical consequence follows directly from its cache equation. For a conventional full-attention cache, holding architecture and cache precision constant, increasing context from 16K to 256K multiplies the cache component by 16. It does not multiply the entire model’s memory requirement by 16, because the weights remain unchanged.
Some architectures use sliding windows, compressed caches or attention mechanisms that change that relationship. llmrun documents special handling for several such designs.
Still, the purchasing and setup advice is straightforward: do not read a 256K context label as a promise that 256K tokens will fit on your selected GPU. For long-document work, cache headroom deserves a separate check before committing to a large download.
Mac Memory Needs a Different Interpretation
Apple Silicon uses a shared memory pool for CPU and GPU workloads. llmrun’s documented rule subtracts 3.5 GB for macOS, so it evaluates a 32 GB Mac against 28.5 GB of available model memory. Other unified-memory devices with fixed GPU limits are checked against those limits.
That reservation is a planning assumption. It is not a live accounting of every application running on the machine. I’d leave additional room when planning to keep a browser, editor and other substantial applications open alongside the model.
Speed Estimates Describe Generation, Not the Whole Wait
llmrun estimates generation speed using memory bandwidth, model size and an efficiency factor. In simplified terms, it divides bandwidth in GB/s by model size in GB, then applies a platform-specific adjustment.
The documentation lists these adjustments:
| Inference platform | llmrun’s efficiency factor |
|---|---|
| NVIDIA CUDA | 65% |
| Apple Metal | 70% |
| AMD ROCm | 60% |
| Intel oneAPI | 50% |
The site says these factors are calibrated against community benchmarks from llama.cpp and Ollama. They are inputs to its prediction model, not independently measured efficiency ratings for every device. Its methodology also allows for changes as software stacks improve.
The central condition is batch size 1: one person generating a response. The displayed tokens-per-second figure describes the decode phase, when the model produces output.
Frequently Asked Questions
3 questions
1Do I Need to Install Anything to Check Compatibility?
No. llmrun provides browser-based hardware detection and manual hardware selection. Installing an inference application and downloading a model are separate steps.
