Local AI readiness. The arithmetic, shown.
Whether a model runs on your machine starts with whether its weights fit in memory the graphics chip can use. This check reads what the browser offers AI runtimes (WebGPU and 16-bit shaders), measures how much graphics memory this page could allocate and verify, and its bandwidth, then shows which model sizes' weights fit, as parameters times bytes per weight. It does not predict tokens per second.
One check · Up to a minute
Asks for: Nothing. It runs in its own window and nothing leaves this page.
In short
Local AI readiness: the answer first
Whether your PC can run an AI model locally starts with memory: the model's weights, parameters times bytes per weight, must fit in memory its graphics chip can use, with room left for context. This check measures how much graphics memory the browser let this page allocate and verify, reads WebGPU and 16-bit shader support, and shows which model sizes fit. It does not predict speed.
Reading your result
- The arithmetic
- A 7 billion parameter model at 4-bit is 7 billion times half a byte, 3.5 GB of weights. The table shows every size at 16-bit, 8-bit and 4-bit against the memory verified.
- Fits is a floor
- Weights only. The context and the runtime's working buffers need more, so a size right at the line will not run.
- Bandwidth
- Shown because generation speed depends on it. The page does not turn it into tokens per second, which also depend on the runtime and the model.
What it measures
Measured here, not assumed.
- WebGPU and shader-f16
- Whether the browser gives a WebGPU adapter, whether it is a fallback that runs on the processor, and whether it offers shader-f16, the 16-bit maths browser runtimes use.
- Memory this page could use
- The VRAM test's allocation: buffers grown in steps up to a cap you choose, each written and read back. What the browser let this page use, not the card's memory.
- Bandwidth
- The VRAM test's copy kernel in GB/s. Generation speed depends on it, so it is shown, but it is not turned into a speed.
- Weights against memory
- For 1 to 70 billion parameters at 16-bit (2 bytes a weight), 8-bit (1) and 4-bit (0.5): parameters times bytes per weight, against the memory this page verified. Weights only; context and working memory come on top.
If it fails
The usual failures, and what fixes each.
- No WebGPU
- Use a current Chrome or Edge, turn on hardware acceleration and update the graphics driver. The WebGPU test shows what is missing.
- A fallback adapter
- The browser is running WebGPU on the processor. Turn hardware acceleration on, update the driver, and on a laptop with two chips set the browser to high performance.
- Too little memory for the size you want
- Choose a smaller model or a lower precision, close other graphics apps, or raise the cap and run again. A native runtime may also do better than the browser on the same machine.
Where a browser stops
What it cannot tell you.
- Tokens per second. Speed depends on the runtime, the model, the context length and the browser; this page does not predict it.
- Native runtimes. A native runtime usually runs faster than a browser one and can use memory the browser does not offer.
- Installed memory. The browser caps what a page can allocate, and reports system RAM only up to 8 GB.
- Real file sizes. A 4-bit file is somewhat larger than half a byte a weight, because it stores scales, and a running model needs memory for its context.
- Free disk space for the model.
Privacy
Nothing leaves this page.
The camera and microphone are read on this page and stopped as soon as they have been measured. The clip you can play back lives in the browser's memory and is discarded when you leave. The location check discards the position. The internet test sends random bytes to this site and nothing else. The result is stored nowhere unless you ask for it by email, and then only the fact that an email was sent is kept.
Questions
Local AI readiness, answered
- Can my PC run AI locally?
- It can run a model whose weights, plus room for its context, fit in memory its graphics chip can use. The check above shows which sizes' weights fit in what the browser let this page allocate. Speed it does not predict.
- How much memory does a 7 billion parameter model need?
- Its weights take 7 billion times the bytes per weight: 14 GB at 16-bit, 7 GB at 8-bit and 3.5 GB at 4-bit. The runtime needs more on top for the context and working buffers.
- Why no tokens per second?
- Because it depends on the runtime, the model's design, the context and the browser, none of which this page can know. A number here would be a guess, so the page shows the measured bandwidth and the arithmetic instead.
- Does this download a model?
- No. Nothing is downloaded and nothing leaves the page.
- Will a native app run models faster than the browser?
- Usually, yes. Native runtimes reach more of the hardware than a browser can, so a size that fits here will generally also fit and run there.
Read next