Aug 25, 2026

CanIRun.ai Went Viral — It's Actually Open Source. Here Are the FOSS Ways to Check What Your GPU Can Run

By AIFoss · 8 min read

hardwareggufvramselfhostedai

TL;DR: CanIRun.ai, the browser tool that grades which local LLMs your machine can run, went viral on Hacker News — and despite early assumptions that it was a closed web service, the site’s code is published under MIT at midudev/canirun.ai, so you can audit or self-host it. If you’d rather never touch a browser fingerprinting API, gguf-parser gives you exact per-model memory estimates from the terminal, and nvidia-smi plus basic quant math gets you 90% of the answer in two commands.

	CanIRun.ai	gguf-parser (CLI)	DIY: nvidia-smi + quant math
Best for	Newcomers who want an instant verdict	Checking a specific GGUF before downloading	People who already know their hardware
Price / Cost	Free, MIT-licensed, self-hostable	Free, MIT-licensed	Free, tools you already have
The catch	Browser VRAM detection is inferred, not measured	You need to know which model file to point it at	You do the arithmetic yourself

Honest take: Use CanIRun.ai to get oriented, then use gguf-parser to sanity-check the exact quant you’re about to download. The browser tool answers “what class of model fits my machine”; the CLI answers “will this file fit at this context size” — and that second question is the one that actually prevents wasted downloads.

The viral moment — and the plot twist

In March 2026, CanIRun.ai hit #1 on Hacker News with over 1,300 upvotes. The pitch is irresistible: open a browser tab, wait a few seconds while it reads your GPU, CPU, and RAM through browser APIs, and get a graded report card — S through F — for dozens of open-weight models, from lightweight 1B chat models up to the heavyweights. No install, no signup, and a promise that no data leaves your device.

The skeptical take, repeated in the HN thread and in most coverage, was that this is a proprietary web service asking you to trust an unverifiable privacy claim. A browser page that enumerates your GPU is collecting exactly the kind of hardware fingerprint that ad-tech loves, and “we don’t send it anywhere” is not something you can confirm from a minified bundle.

Except you can confirm it, because the source is public. The site is developed in the open at midudev/canirun.ai on GitHub under an MIT license, with the repository listing canirun.ai as its homepage. It’s an Astro 5 + Tailwind site, and the interesting parts live in a small monorepo: a package of model definitions covering 55+ curated models with seven quantization levels each, a hardware compatibility scoring engine, and even a CLI. Hardware detection runs client-side.

That changes the article we originally planned to write. The question is no longer “what FOSS alternative should replace this closed tool” — it’s “which of the open options fits your workflow,” because the viral one is already in that set.

How CanIRun.ai actually works — and where browser detection hits its ceiling

The detection layer uses standard browser APIs: the WebGL renderer string identifies your GPU model, navigator APIs report CPU core counts and approximate memory, and the scoring engine maps that against its model catalog to produce per-model grades across quantization levels.

Here’s the honest limitation, and it applies to every browser-based checker, open or closed: browsers do not expose an actual VRAM reading. There is no API that returns “24576 MB.” What these tools do is match your GPU’s model string against a specification table — the page sees “RTX 3090,” looks up that the RTX 3090 ships with 24GB, and proceeds from there. That works fine for well-known desktop cards. It gets fuzzier with laptop variants that share names with desktop parts while carrying less VRAM, virtualized GPUs, and multi-GPU rigs, where the renderer string may only reflect the primary adapter.

So treat the browser verdict as a well-informed estimate, not a measurement. For the majority of home setups it’s accurate; for edge cases, verify locally with the tools below. Our sister site ran the tool against known hardware and published the accuracy results in its CanIRun.ai review.

There are other web checkers in the same space — caniusellm.com is the most visible — but we could not verify published source code for them at the time of writing, so the same audit-it-yourself argument doesn’t apply there.

Option 2: gguf-parser — exact answers for a specific file

If CanIRun.ai answers “what can my machine run in general,” gguf-parser from the GPUStack project answers the sharper question: will this exact GGUF file, at this exact context size, fit in my memory? It’s MIT-licensed, written in Go, ships as a single binary, and — this is the clever part — it reads only the metadata of a remote GGUF file using ranged requests, so you get a full memory estimate without downloading a 40GB model first.

Point it at any GGUF on Hugging Face:

gguf-parser \
  --hf-repo bartowski/Qwen2.5-72B-Instruct-GGUF \
  --hf-file Qwen2.5-72B-Instruct-Q4_K_M.gguf \
  --ctx-size 16384

You get a breakdown of estimated RAM and VRAM usage, split across weights, KV cache, and compute buffers. The flags that matter for self-hosters:

--ctx-size — the single biggest lever people forget. KV cache grows with context, and a model that fits at 4K may not fit at 64K. See our context window guide for why this matters more than parameter count.
--tensor-split — models a multi-GPU split, so dual-card rigs get realistic per-device numbers.
--device-metric — feed it your GPU’s bandwidth and FLOPS and it estimates maximum tokens per second, not just fit.

This is the tool to run before every large download. It has saved us from at least one “the Q4 fits but the KV cache doesn’t” mistake while preparing setup guides.

Option 3: the two-command DIY path

If you’d rather not install anything, you can replicate the core of what these checkers do with tools already on your machine. First, get your actual VRAM — measured, not inferred:

nvidia-smi --query-gpu=name,memory.total --format=csv
# AMD: rocm-smi --showmeminfo vram
# Apple Silicon: unified memory is your ceiling; check "About This Mac"

Then apply the rule of thumb: a GGUF’s file size is roughly what the weights need in memory, plus 1–3GB of overhead for the KV cache and compute buffers at moderate context sizes (and considerably more at 32K+). A 7B model at Q4_K_M is about 4.4GB on disk, so it runs comfortably on an 8GB card. A 24GB RTX 4090 handles ~20GB quants with headroom. Our GGUF quantization guide has the full size table per quant level, and the file sizes themselves are listed on every Hugging Face repo page — no tooling required.

The DIY path is also the only one that reflects your actual free VRAM. Browser tools assume the card is empty; nvidia-smi shows you the 1.5GB your desktop compositor is already holding.

Which one should you use?

Starting from zero, don’t know what a quant is: CanIRun.ai. The graded catalog is a genuinely good on-ramp, and being MIT-licensed removes the trust objection — clone it and run it locally if the fingerprinting still bothers you. Then install Ollama and pull whatever it graded S or A.

About to download a specific model: gguf-parser, every time. It’s the only option here that accounts for context size, and quant-aware models like the Gemma 4 QAT builds make per-file checking more important, not less.

Comfortable with a terminal: the DIY path is faster than opening a browser, and it’s the only method that measures rather than infers.

And if the answer comes back “no, your hardware can’t run it” — you don’t have to buy a GPU to experiment. Renting an A100 or 4090 by the hour on RunPod is the cheaper way to test whether a big model is even worth building hardware around.

When NOT to bother with any of this

If you run everything through Ollama at default context sizes and stick to models under 10B, you don’t need a checker — Ollama’s own error messages and ollama ps output tell you when you’ve overreached. These tools earn their keep at the margins: big MoE models, long contexts, multi-GPU splits, and partial CPU offload, where “will it fit” stops being obvious.

FAQ

Is CanIRun.ai safe to use, privacy-wise? The source code is published under MIT at midudev/canirun.ai and hardware detection runs client-side in the repo we reviewed. If you want certainty rather than trust, clone the repository and self-host it — that option is exactly what separates it from closed web checkers.

Why does my laptop GPU get graded wrong? Browser tools infer VRAM from your GPU’s model name. Laptop cards often share a name with desktop parts while shipping less VRAM, so the lookup table can be optimistic. Verify with nvidia-smi — it reads the real number.

Can gguf-parser check a model I haven’t downloaded? Yes — that’s its main trick. It fetches only the GGUF metadata from Hugging Face via ranged requests, then estimates RAM/VRAM and even tokens per second for your declared hardware, all without downloading the weights.

Recommended Gear

RTX 3090 — 24GB VRAM, still the used-market value pick for local LLMs
RTX 4090 — 24GB with roughly double the compute for faster prompt processing

Sources

Was this article helpful?

What self-hosting actually costs

Real cost breakdowns for self-hosted AI: hardware floors, power, maintenance hours, and the honest comparison against paying for it. No spam, unsubscribe anytime.