TL;DR: CanIRun.ai opens in a browser tab and grades every open-weight LLM (S through F) against your machine for each quantization level — no install, no signup, nothing leaves your device. It’s genuinely useful for a first-pass “will this fit?” check. The catch: WebGPU deliberately hides your true VRAM, so the tool infers hardware from your GPU’s name and a spec database, then estimates tokens/sec from a bandwidth formula. Treat its grades as a shortlist, not a benchmark.

	CanIRun.ai	Manual VRAM math	Real benchmark run
Best for	First-pass “does it fit?”	Exact quant-level planning	Actual tok/s on your rig
Cost / effort	10 seconds, browser	20 min + a spreadsheet	Download + test, ~1 hr
The catch	Estimates VRAM & speed	You do the arithmetic	Only tests what you own

Honest take: Use CanIRun.ai to narrow a dozen models down to three in ten seconds, then confirm the survivors with real per-model numbers before you buy a GPU or commit to a download.

CanIRun.ai landed on the front page of Hacker News on March 13, 2026 and pulled somewhere between 685 and 899 points with roughly 200–235 comments in a day, depending on which snapshot you read. It struck a nerve because it answers the single most-asked question in the local-AI community — “can my machine actually run this?” — without making you install anything or read a VRAM table. Built by Miguel Ángel Durán García (midudev), it’s free, client-side, and refreshingly honest about its own limits. This review covers how it works under the hood, how accurate its numbers really are, where it breaks, and when you should reach for something more precise.

What CanIRun.ai actually does

You open canirun.ai and it tries to detect your hardware automatically. If your browser supports WebGPU, it requests a GPU adapter to read device and architecture details, pulls CPU thread count from navigator.hardwareConcurrency, and estimates system RAM. Then it cross-references your specs against a catalog of open-weight models from Meta, Alibaba, Google, Microsoft, Mistral, DeepSeek, OpenAI, NVIDIA, and others.

Every model gets a letter grade — S through F — and the grade is per-quantization. So a single model like Llama or Qwen shows a row of grades across Q2_K, Q4_K_M, Q5_K_M, Q6_K, Q8_0, and F16, ranging from “Runs great” down to “Too heavy.” That per-quant breakdown is the tool’s best feature: it’s the difference between “you can’t run this” and “you can run this at Q4 but not Q6,” which is exactly the decision most home-lab builders are actually making.

Click into any model and you get architecture type, context window, and the memory footprint at each quantization level. There’s also a browser Playground that runs small models directly via WebGPU, which is a nice touch for a zero-commitment demo but not where the real value is.

The privacy posture is correct for this audience: detection runs entirely in your browser. Your hardware fingerprint, the models you looked at, and your IP-based location are not the product. For a tool aimed at people who run models locally specifically to keep data off someone else’s servers, that’s the only defensible design.

The thing most reviews miss: WebGPU can’t read your VRAM

Here’s the technical detail that changes how you should read every grade this tool produces.

The WebGPU specification deliberately does not expose total or available GPU memory. It’s a privacy decision — VRAM capacity is a fingerprinting vector that helps identify specific hardware. What WebGPU does expose, through adapter.limits, is a set of ceilings like maxStorageBufferBindingSize, which runs from about 128 MB on mobile to 4 GB on desktop. That number is a per-buffer binding limit, not your card’s memory. A 24 GB RTX 3090 and a 10 GB RTX 3080 can report the exact same 4 GB desktop ceiling.

So how does CanIRun.ai know you have 24 GB? It doesn’t measure it. It reads your GPU’s name from the adapter and looks the capacity up in a spec database. That works well for discrete desktop cards with clean names. It gets shaky when:

• The adapter reports a vague or generic GPU name (common on some drivers and browsers).
• You’re on a laptop with an integrated GPU or a mobile-binned chip.
• You’re on Apple Silicon, where memory is unified and shared with the CPU.

When the browser can’t get a clean adapter handle, the tool falls back to a manual entry form where you pick your GPU and RAM yourself. That’s the right call — but it also means that in the fuzzy cases, CanIRun.ai is grading the hardware you told it about, not hardware it measured. Worth knowing before you trust a borderline grade.

How accurate is the tokens/sec estimate?

CanIRun.ai doesn’t just say “it fits” — it estimates speed, and it’s transparent about the formula:

tokens/sec ≈ Memory bandwidth (GB/s) ÷ Model VRAM (GB) × Efficiency

where efficiency is 0.70 for discrete GPUs and 0.65 for Apple Silicon. The tool itself calls this conservative and warns real-world results vary ±20% with batch size, context length, and quant format.

This formula is actually sound in principle, because LLM decode (generating one token at a time) is memory-bandwidth-bound, not compute-bound — the GPU has to stream the model’s weights out of VRAM for every token. Let’s check it against a card we have solid numbers for.

Test case: RTX 3090, Llama 3 8B, Q4_K_M

• RTX 3090 memory bandwidth: 936 GB/s (GDDR6X, 384-bit)
• Model footprint at Q4_K_M including a modest KV cache: roughly 6–6.5 GB
• Formula: 936 ÷ 6.5 × 0.70 ≈ ~100 tok/s

Real-world single-user throughput for an 8B model at Q4_K_M on an RTX 3090 lands around 80–100 tok/s in practice. So the formula’s estimate sits at the optimistic edge of reality — right where you’d expect a bandwidth-ceiling calculation to land, since it assumes near-perfect bandwidth utilization and ignores thermal throttling, driver overhead, and OS memory pressure. Within the ±20% band the tool advertises, it’s honest.

The takeaway: the tokens/sec number is a good upper-bound sanity check, not a promise. If CanIRun.ai says 100 tok/s, plan for 80. If it says 15 tok/s, assume something closer to 12 — which, for a chat model, is the line between “usable” and “annoying.” For where your specific model and GPU actually land, our benchmark-tool roundup walks through measuring it yourself.

Apple Silicon: the known weak spot

CanIRun.ai handles Apple’s unified memory by treating the whole pool as shared and capping usable memory at 75% — a reasonable heuristic, since macOS reserves the rest and won’t let a single process grab everything. But this is where grades skew most optimistic. Unified memory bandwidth varies enormously across the M-series lineup (a base chip and a Max part are worlds apart), browser-reported GPU names for Apple Silicon are coarse, and the 0.65 efficiency factor is a single number applied across very different silicon.

The practical result: on a Mac, treat a borderline grade with extra skepticism, and cross-check against real Apple numbers. Our Mac Studio M4 Max vs Mac Mini M4 Pro comparison has measured tok/s figures that will tell you far more than a letter grade.

Coverage: does it have the models you care about?

Model coverage is broad and updated reasonably often, spanning the major open-weight families. As of this writing it does well on the mainstream lineup — Llama, Qwen, Gemma, Phi, Mistral, DeepSeek. Where any catalog-based tool struggles is the bleeding edge: brand-new releases and exotic MoE architectures take time to land, and the memory math for large mixture-of-experts models is genuinely hard to reduce to one number.

That last point matters. For a model like Kimi K2.7 or a 35B-A3B MoE like Qwen 3.6 35B-A3B, “total parameters” and “active parameters per token” pull in opposite directions — storage is dominated by total size, but decode speed is driven by the much smaller active set. A single VRAM figure and one tok/s number can’t fully capture that. If the model you’re eyeing is a large MoE, verify against a dedicated writeup rather than a grade.

Where CanIRun.ai fits vs. where it doesn’t

Use it when:

• You’re new to local AI and want a fast, jargon-light “will this run?” before downloading 15 GB.
• You’re shortlisting — narrowing a dozen candidate models down to the two or three worth testing.
• You want a quick reality check on a GPU you’re considering, before the deeper spec dive.

Reach past it when:

• You’re making a purchase decision. A grade won’t tell you whether you’ll get 3 tok/s or 30, and that gap is the whole ballgame. Pair it with real benchmarks and our best local models by VRAM tiers.
• You need exact quant-level planning with KV-cache and context math — do the arithmetic (our best LLM for every RTX 50-series GPU guide shows the method).
• You’re on Apple Silicon or an oddball laptop GPU, where detection is fuzziest.
• You don’t have the hardware yet at all. If you’re renting, a cloud GPU on RunPod sidesteps the whole “can I run it” question — you just pick a card with enough VRAM and go.

If you’re building a rig from scratch on a tight budget, our $500 local LLM build pairs well with a CanIRun.ai check: pick the parts, then confirm the grades before you buy.

The honest verdict

CanIRun.ai is the best free “can I run it?” tool available right now, and it earns its Hacker News reception. It’s fast, private, transparent about its formulas, and honest that its outputs are estimates. The per-quantization grades are the standout feature — they map directly to the decision real builders face.

But understand what you’re looking at. It does not measure your VRAM (WebGPU won’t let it), it does not measure your speed (it calculates a bandwidth ceiling), and it does not know about thermal throttling or your specific driver stack. It’s a well-built estimator, and the moment real money or a real download is on the line, you should confirm its shortlist against actual numbers.

For newcomers building their first local AI machine, it’s a great starting point. For power users who already know their VRAM math, it’s a fast sanity check and little more. Either way — verify before you buy.

Building a coding-focused rig instead? Our sister site aicoderscope.com covers local AI coding tools like Cline and Continue.dev, and aifoss.dev tracks the open-source inference stack these tools all depend on.

FAQ

Does CanIRun.ai actually read my GPU’s VRAM? No. The WebGPU spec deliberately hides total GPU memory as an anti-fingerprinting measure. CanIRun.ai reads your GPU’s name and looks the capacity up in a spec database, or asks you to enter it manually when the name is unclear. Its VRAM figure is a lookup, not a measurement.

Are the tokens/sec estimates reliable? They’re a reasonable upper bound. The tool uses bandwidth ÷ model size × efficiency (0.70 discrete, 0.65 Apple Silicon), which tracks real numbers within roughly ±20%. On an RTX 3090 running an 8B model at Q4_K_M, its formula lands near ~100 tok/s versus ~80–100 tok/s in practice — optimistic, but in the right ballpark. Plan for the low end.

Is it accurate on Apple Silicon Macs? Less so. It treats unified memory as a single pool capped at 75% usable, which is sensible, but M-series bandwidth varies widely and browser GPU detection is coarse. Grades on Macs skew optimistic — cross-check against real Apple benchmarks.

Does it cost anything or need an account? No. It’s free, runs entirely in your browser, requires no installation and no signup, and sends no data off your device.

Should I trust it enough to buy a GPU based on its grades? Use it to shortlist, not to decide. A letter grade tells you a model fits; it doesn’t tell you whether you’ll get a comfortable 30 tok/s or a painful 3. Confirm the shortlist with real per-model benchmarks before spending money.

What if my browser can’t detect my hardware? CanIRun.ai falls back to a manual entry form where you select your GPU and RAM. The grades are then only as accurate as what you enter — which is usually fine if you know your exact card.

Sources

• CanIRun.ai — official site — tool homepage, hardware detection and grading.
• CanIRun.ai — Why / methodology page — tokens/sec formula, efficiency factors, Apple Silicon 75% cap, and stated limitations.
• WebGPU specification — W3C — adapter limits including maxStorageBufferBindingSize.
• Support for querying maximum/available GPU memory — gpuweb Issue #5505 — confirms WebGPU deliberately does not expose total/available VRAM.
• WebGPU Memory Limits: maxStorageBufferBindingSize — Ayoob AI — real-world range of the desktop/mobile buffer ceilings.
• 685 Hacker News Upvotes in One Day — Top AI Product — HN launch date and reception.
• midudev/canirun.ai — GitHub — creator and source.

Recommended Gear

The two GPUs this review keeps coming back to as CanIRun.ai’s sweet-spot picks:

• RTX 3090 24GB — the used-market value king for 24 GB of VRAM and 936 GB/s bandwidth.
• RTX 4070 Ti 12GB — a solid new-card mid-range pick for models that fit in 12 GB.

Prices and product availability move weekly; figures cited are as of July 2026.