CanIRun.ai - running local AI models on a computer - 2026

Published: 2026-07-29

CanIRun.ai is a free web service that checks your computer's compatibility with local large language models (LLMs). The service analyzes hardware specifications directly in the browser and shows which AI models your machine can run, at what speed, and in which quantization. The project was created by Spanish developer Miguel Angel Duran Garcia (midudev) and is published as open-source software on GitHub.

Overview

CanIRun.ai solves a common problem for anyone who wants to run large language models locally: how do you know whether a particular model will work on your machine without downloading tens of gigabytes blindly? Before this service appeared, users had to study VRAM tables, read discussions on Reddit and Discord, and dig through llama.cpp documentation — a process that could take hours.

The service reduces this check to a single action: open the website. Everything else happens automatically. The page detects your GPU, VRAM amount, RAM, and CPU, then displays a list of models with grades from S ("Runs great") to F ("Too heavy"). No installations, no registration, no data sent to any server — all computations happen locally in the browser.

How it works

Hardware detection

CanIRun.ai uses three browser APIs to identify hardware:

WebGL — creates an invisible canvas and uses the WEBGL_debug_renderer_info extension to get the exact GPU name and vendor. For example: "ANGLE (NVIDIA, NVIDIA GeForce RTX 4090, ...)" or "Apple M4 Pro GPU".
WebGPU — requests an adapter to get additional device and architecture information.
navigator.hardwareConcurrency — detects the number of CPU cores.

Based on the GPU name, the service looks up a built-in specification database to obtain VRAM capacity and memory bandwidth. These numbers come from official manufacturer specifications, not direct measurements — the browser has no API for determining exact VRAM size.

Grading system (S–F)

Each model receives a letter grade for a selected quantization:

Grade	Meaning
S	Runs great
A	Runs well
B	Decent
C	Tight fit
D	Barely runs
F	Too heavy

The grade is calculated based on whether the model (with the chosen quantization) fits into VRAM with headroom and what generation speed is predicted.

Quantization

Quantization reduces the precision of a model's weights, making it smaller and faster at the cost of some quality. CanIRun.ai shows available quantization options for each model:

Format	Bits	Quality	Notes
Q2_K	2	Low (~60%)	Smallest size, noticeable quality loss
Q4_K_M	4	Good (~88%)	Best balance of size and quality — most popular
Q6_K	6	Very good (~95%)	Near-lossless
Q8_0	8	Excellent (~99%)	Minimal quality loss
F16	16	Original (100%)	Full precision, largest size

By default, the service uses Q4_K_M as the most balanced option, but the user can switch to any other quantization and see how the grade changes.

Speed prediction (tokens/sec)

Generation speed is estimated based on GPU memory bandwidth. The approximate formula is: t/s = bandwidth (GB/s) / model size (GB). This provides only a rough estimate — real-world speed depends on many factors that the browser cannot measure.

Features

Main page with model catalog

The main page displays a full catalog of supported models with filtering by:

Grade — only those that run great (S/A/B), tight fit (C/D), too heavy (F)
Task type — Chat, Code, Reasoning, Vision
Provider — Alibaba, Allen AI, Cohere, DeepSeek, Google, Hugging Face, LG AI, Liquid AI, Meta, Microsoft, Mistral AI, Moonshot AI, NVIDIA, OpenAI, Zhipu AI
License — Apache 2.0, CC BY-NC 4.0, MIT, Llama Community, NVIDIA Open, and others
Sorting — by size (parameters), date, context length, speed, VRAM required, popularity

Each model displays: name, developer, parameter count, release date, architecture (Dense or MoE), required VRAM, context length, available quantization options, and task tags.

Tier List

A dedicated page that displays all models in a classic tier list format from S to F. This allows for quick visual assessment of which models are available for a given machine. The list can be downloaded as an image or copied to the clipboard.

Compare Devices

Allows comparing two devices side by side to see which models run on each and with what grade. By default, it compares the current device against a MacBook with M5 Max. Useful when choosing a new computer or planning an upgrade.

Playground (browser-based inference)

The most ambitious component — a full chat interface that runs AI models directly in the browser via WebGPU. No servers, no API keys — the model downloads once, caches locally, and all subsequent sessions work offline. Supports uploading images, PDFs, and text files. Users can configure system prompt, temperature, max tokens, and top-p.

Supported models

As of mid-2026, the service supports hundreds of models including all major families:

Llama — 3.1 (8B, 70B, 405B), 3.2 (1B, 3B, 11B, 90B), 3.3 (70B), 4 (8B, 17B, 70B, 405B)
Qwen — 2.5 (0.5B–72B, Coder), 3 (0.6B–235B), 3.5 (0.8B–235B, including multimodal)
DeepSeek — V2, V3, R1 (1.5B–671B), Coder
Gemma — 2 (2B–27B), 3 (1B–27B), 4 (5B–40B)
Mistral — 7B, Nemo, Small 3.1 (24B), Large 2 (123B)
Phi — 3.5 Mini (3.8B), 4 Mini Reasoning, 4 (14B)
GLM, Command, Nemotron, Stable LM, Ornith, Falcon, Yi and many others

The database is updated regularly — models appear shortly after their official release.

Technical limitations

The service honestly warns that all results are estimates, not guarantees. Key limitations include:

VRAM is determined by GPU name and a specification database, not measured directly. Browser APIs do not expose exact VRAM — WebGPU deliberately hides this information.
Does not account for drivers, thermal throttling, background processes, OS memory pressure, SSD speed, temperature, firmware version — all factors that can significantly affect performance.
Apple Silicon with unified memory may have inaccuracies, especially on edge configurations (e.g., MacBook with 8GB RAM).
Integrated GPUs (Intel Iris, AMD Radeon integrated) typically receive D or F grades for any serious model.
Generation speed (tokens/sec) is a rough estimate based on bandwidth. Real speed can differ by 2–3x depending on implementation and hardware.

The creator, midudev, recommends using CanIRun.ai as a first-pass filter: narrow down hundreds of models to 2–3 candidates in 10 seconds, then validate them in practice using Ollama, LM Studio, or llama.cpp.

Hacker News and popularity

The project hit the front page of Hacker News on March 13, 2026, where it scored between 685 and 899 points and generated roughly 200–235 comments in a day. The high interest reflects the fact that the service solves a pressing problem for the local AI community — determining compatibility without installing software or reading documentation.

Pros and cons

Pros	Cons
No installation required — works in browser	Estimates only, not a precise benchmark
Completely free	VRAM determined from spec database, not directly
Instant results (5–10 seconds)	Does not account for drivers, throttling, OS
Data never leaves your device	Inaccuracies on Apple Silicon unified memory
Huge model database (hundreds)	Not suitable for fine-grained upgrade planning
Playground with WebGPU inference	Requires modern browser with WebGPU
Device comparison mode	Not all models available in Playground
Open source	VRAM accuracy depends on the spec database

Practical use

CanIRun.ai is useful for users of the following local AI tools:

Ollama — the most popular tool for running LLMs locally
LM Studio — graphical interface for local models
llama.cpp — fast C++ inference engine
Jan — desktop AI client
Open WebUI — web interface for Ollama/llama.cpp

A typical use case: a user visits CanIRun.ai, sees that Qwen 3.5 9B in Q4_K_M quantization gets a C grade ("Tight fit"), but can be run in Q2_K with a B grade ("Decent"). The user downloads the Q2_K version, tests its performance, and if the speed is acceptable, upgrades to a higher quantization.

For choosing new hardware, the service is also useful: compare the current machine with a potential purchase and see which models would become available.

Conclusion

CanIRun.ai is a well-executed tool for initial assessment of computer compatibility with local AI models. It does not replace real benchmarking, nor does it claim to. Its goal is to save time: instead of downloading a 30GB model only to find it does not fit in VRAM, the user learns this in 5 seconds.

The service is especially useful for beginners who are just starting with local AI and do not want to dive into the intricacies of quantization, VRAM sizes, and memory bandwidth. Experienced users will also find value — fast filtering and device comparison help make upgrade decisions.

As of mid-2026, CanIRun.ai remains the best free tool in its niche. Thanks to its open-source code and active community support, it continues to evolve: new models are added, hardware detection accuracy improves, and Playground functionality expands.

Summary

Name: CanIRun.ai
Type: PC-to-AI-model compatibility checker
Developer: Miguel Angel Duran Garcia (midudev)
Launch date: 2026
Cost: Free
Source code: Open source (GitHub)
Technologies: WebGL, WebGPU, JavaScript, React
Interface language: English
Primary purpose: Determine which local AI models are compatible with user hardware
Key feature: Everything works in the browser, no data sent to any server
Grading: S–F scale based on VRAM, RAM, bandwidth, and CPU core count

Links

×