Skip to content
PocketWebToolsPocketWebTools
Get the Mac app
All tools

What GPU do I have?

The box below shows the GPU your browser reports: Chrome and Edge name the exact model, Safari says only “Apple GPU” and Firefox shows a stand-in, and no browser reports video memory, so we ask for it. For local AI the video memory is what counts: Qwen3 14B at Q4_K_M needs about 11.0 GB at 8,192 tokens, which runs on a 16 GB GeForce RTX 4060 Ti and spills out of an 8 GB GeForce RTX 4060.

Your GPU

Reading your GPU from the browser…

Everything here stays in your browser. We never send your GPU name or memory anywhere.

Confirm your machine

Your computer

What your browser can and cannot tell

  • Chrome, Edge and Opera report the exact model, usually with the card's PCI device ID. On a Mac they name the Apple chip, for example “ANGLE (Apple, ANGLE Metal Renderer: Apple M2 Pro, ...)”.
  • Safari always reports “Apple GPU”, on Intel Macs, iPhones and iPads too.
  • Firefox swaps the real GPU for a representative one followed by “, or similar”: every Apple chip reads as Apple M1, and an RTX card as an older GeForce. You learn the brand, not the model.
  • No browser reports video memory. Chrome can read the GPU's memory heaps through WebGPU only behind a developer flag.
  • Chrome, Edge and Opera report system memory, but rounded to 2, 4, 8, 16 or 32 GB and capped at 32 on desktop. Safari and Firefox do not report it.
  • The browser never names which version of an Apple chip you have, and on some chips that sets memory speed: M3 Max (300 or 400 GB/s), M4 Max (410 or 546 GB/s) and M5 Max (460 or 614 GB/s). Each memory size comes in one version only, so your memory pick settles it.

So the box above shows what the browser read, says what it could not, and asks you for the rest. It works the same in every browser once you confirm your machine.

How to check your GPU on Windows

  1. Settings: choose Settings > System > Display, scroll to Related settings and choose Advanced display. Your GPU's make and model are under Display information.
  2. Task Manager: right-click the Start button, choose Task Manager, then Performance, then GPU (near the bottom of the list). The model is in the top-right corner.
  3. NVIDIA cards: right-click the desktop, choose NVIDIA Control Panel, then System Information in the bottom-left corner. It lists the GPU, the driver version, the amount of video memory and, further down, the device ID.

The video memory matters because some cards are sold in two sizes under one name, such as the GeForce RTX 5060 Ti, GeForce RTX 4060 Ti and GeForce RTX 3060, and the two sizes run different models.

How to check your GPU on a Mac

  1. Choose Apple menu > About This Mac. A Mac with Apple Silicon shows Chip followed by the chip's name; an Intel Mac shows Processor instead.
  2. For more detail, hold the Option key and choose Apple menu > System Information. You can also choose Apple menu > System Settings > General > About, then System Report.

On Apple Silicon the GPU is part of the chip and uses the Mac's unified memory, so there is no separate video memory to look up. macOS lets the GPU use part of that memory by default: about 12.7 GB of a 16 GB Mac on macOS 26 and later. Which AI models a Mac runs at each memory size goes through it size by size.

Why video memory decides which AI models run

A model needs its file, memory for the context and room for the runtime. Qwen3 14B at Q4_K_M with 8,192 tokens needs 9.0 GB of weights, 1.3 GB of context memory and 0.7 GB for the runtime: about 11.0 GB in all.

Same model, different GPUs

Qwen3 14B at Q4_K_M with 8,192 tokens of context. Estimated, not measured.

Same model, different GPUs
ModelMachineNeeds / GPU can useReply speedVerdict
Qwen3 14BQ4_K_M, 8,192 tokensGeForce RTX 4060, 8 GB11.0 GB of 7.5 GB3.5 GB in system memory8.3 to 9.8 tok/sEstimateTight
Qwen3 14BQ4_K_M, 8,192 tokensGeForce RTX 3060, 12 GB11.0 GB of 11.5 GB29 to 34 tok/sEstimateTight
Qwen3 14BQ4_K_M, 8,192 tokensArc B580, 12 GB11.0 GB of 11.5 GB36 to 43 tok/sRough estimateTight
Qwen3 14BQ4_K_M, 8,192 tokensGeForce RTX 4060 Ti, 16 GB11.0 GB of 15.5 GB24 to 28 tok/sEstimateRuns well
Qwen3 14BQ4_K_M, 8,192 tokensGeForce RTX 4090, 24 GB11.0 GB of 23.5 GB76 to 89 tok/sEstimateRuns well
Qwen3 14BQ4_K_M, 8,192 tokensRadeon RX 7900 XTX, 24 GB11.0 GB of 23.5 GB72 to 85 tok/sRough estimateRuns well
Qwen3 14BQ4_K_M, 8,192 tokens8 GB A18 Pro11.0 GB of 5.7 GBDoes not fitWon't fit
Qwen3 14BQ4_K_M, 8,192 tokens16 GB M511.0 GB of 12.7 GB13 to 15 tok/sEstimateRuns well
Qwen3 14BQ4_K_M, 8,192 tokens24 GB M5 Pro11.0 GB of 19.1 GB25 to 29 tok/sEstimateRuns well

Rough estimates are for hardware with no calibration points of its own (AMD and Intel cards borrow NVIDIA's). A Mac's usable memory is the share macOS 26 and later gives the GPU by default; for 8 GB Macs we assume a conservative two thirds. Reply speed is in tokens per second at short context. Measured figures come from published runs; estimates come from memory bandwidth, as explained under How we estimate.

When a model does not fit, llama.cpp-style runtimes put the rest in system memory, which is much slower. On the 8 GB GeForce RTX 4060, 3.5 GB of Qwen3 14B runs from system memory and the estimate drops to 8.3 to 9.8 tokens per second, against 24 to 28 on the 16 GB GeForce RTX 4060 Ti.

Two cards with the same name can give different answers. gpt-oss-20b at MXFP4 needs about 13.0 GB: the 16 GB GeForce RTX 5060 Ti holds it all (Runs well, 97 to 114 tokens per second estimated), while the 8 GB version spills into system memory (Tight, 23 to 28 estimated).

Not this machine?

The checker opens set to GeForce RTX 4060 Ti, 16 GB. Change it to your own machine to see what fits and how fast it should reply.

Check your PC

Run AI on this GPU

First, see which AI models your computer can run: confirm your machine in the box above and the checker opens on it.

To run a chat model yourself, these apps are where most people start. Pick a model the checker grades Runs well.

LM Studio

Download and chat with open models in an app.

Free download, closed source. Its terms allow some features to cost extra. Made by another developer, not PocketWebTools.

Get LM Studio

Ollama

Run open models from the command line or other apps.

Free and open source (MIT licence). Made by another developer, not PocketWebTools.

Get Ollama

llama.cpp

The engine many local apps use, for full control.

Free and open source (MIT licence). Made by another developer, not PocketWebTools.

Get llama.cpp

Want to try AI on this computer right now? These tools run in your browser.

Audio TranscriptionTurns speech into text with Whisper, on your GPU through WebGPU where the browser supports it.Open Audio TranscriptionText to SpeechReads text aloud with Kokoro, in your browser.Open Text to SpeechBackground RemoverCuts the background out of a photo, in your browser.Open Background Remover

How we estimate

Show the formulas, constants and sources

Memory a model needs

Memory = weights + context memory + runtime. Weights are the real download size of the file you pick, read from Hugging Face. When a size is unknown we use parameters x bits per weight / 8, with typical averages per quant type (Q2_K 2.96, Q3_K_M 3.91, Q4_K_M 4.8, UD-Q4_K_XL 4.9, MXFP4 4.25, NVFP4 4.5, Q5_K_M 5.7, Q6_K 6.56, Q8_0 8.5, BF16 16). Runtime is 0.7 GB, or 2% of the weights when that is more, for compute buffers and allocator slack: measured buffers stay near that size whatever the model. Against our own Mac app's measured memory for six models, and Apple's published totals for two models at 65,536 tokens, this lands within 15%. Where someone measured the memory of the exact file, we use that run instead and say so. Checked 2026-10-19.

Context memory (KV cache)

Each token of context stores keys and values: 2 x layers x KV heads x head size x 2 bytes (16‑bit cache, the default in llama.cpp and MLX), read from each model's config.json. Sliding-window layers keep at most their window (2,048 tokens on Muse Spark Open, for example), so they add a fixed amount instead of growing. MLX is confirmed to cap them on Muse Spark Open; whether llama.cpp does for that model is not verified, so its GGUF figures may run low at long context. Models with compressed attention (MLA) store one small latent per layer. Linear-attention layers keep a small fixed state, counted in the runtime share. In llama.cpp you can store the cache at lower precision with --cache-type-k and --cache-type-v (-ctk and -ctv): per element that is q8_0 1.0625 bytes, q4_0 0.5625 bytes, from the size of each type's data blocks. A lower-precision V cache needs flash attention, which llama.cpp turns on by itself unless you switch it off. Measured runs are taken to use the 16‑bit default. Checked 2026-10-19.

How much memory a Mac's GPU can use

macOS only lets the GPU use part of a Mac's memory. Apple publishes no formula, so we read the default from public llama.cpp, Ollama and MLX logs where one exists. On macOS 26 and later: 8 GB: 2/3, about 5.7 GB (medium evidence); 16 GB: 0.74, about 12.7 GB (strong evidence); 18 GB: 0.74, about 14.3 GB (medium evidence); 24 GB: 0.74, about 19.1 GB (strong evidence); 32 GB: 0.78, about 26.8 GB (strong evidence); 36 GB: 0.78, about 30.2 GB (medium evidence); 48 GB: 0.78, about 40.2 GB (strong evidence); 64 GB: 0.81, about 55.7 GB (strong evidence); 96 GB: 0.81, about 83.5 GB (weak evidence); 128 GB: 0.84, about 115.4 GB (strong evidence); 192 GB: 0.84, about 173.2 GB (weak evidence); 256 GB: 0.87, about 239.1 GB (weak evidence); 512 GB: 0.87 (assumed), about 478.3 GB (unconfirmed evidence). Why the weaker rows are weaker: 96 GB: One log, from 2026-09-30. 192 GB: One M2 Ultra log, from 2025-10-30. 256 GB: Two M3 Ultra logs, possibly from the same person. 512 GB: No confirmed default. Logs show 464 GiB (about 0.906), but the same value appears on a macOS 15 Mac, so it is probably a manual override. We use 0.87, the 256 GB ratio, which may understate a 512 GB Mac by about 20 GB. On macOS 15 or earlier it was 2/3 up to 32 GB and 3/4 above. The limit can be raised with sudo sysctl iogpu.wired_limit_mb=<MiB>; it resets on restart and macOS needs memory of its own, so leave headroom. The setting cannot go past a second limit, the kernel's cap on all locked memory, which Apple's open-source macOS kernel sets by memory size (16 GB: 13.1 GB; 32 GB: 27.1 GB; 64 GB: 56.3 GB; 128 GB: 116.8 GB; 256 GB: 241.9 GB; 512 GB: 515.4 GB) and two measured Macs match exactly. That cap sits a little above the default at every size, so the default is what a model gets, and we suggest the setting only when a model fits under the cap. It may still fail. Checked 2026-10-19.

Several Macs linked together

For a group of Macs with the same memory, we add up what each one's GPU can use: two 256 GB Macs on macOS 26 and later come to about 478.3 GB. Assumes the model splits evenly across Macs of the same memory size (as exo and MLX distributed do) and that linking them costs no memory on any one Mac. Neither is measured. We give no estimated speed for a group; only published runs, each with its number of Macs. Checked 2026-10-19.

How much memory a PC can use

On a graphics card we take its video memory minus 0.5 GB for the display. Runtimes like llama.cpp, LM Studio and Ollama can put layers that do not fit into system memory; we allow up to 60% of it, and any model that needs it is graded Tight. Both numbers are our assumptions, not measurements. AMD documents up to 96 GB of GPU memory on a 128 GB Ryzen AI Max machine; on smaller ones we assume the same 75% share. NVIDIA publishes no GPU limit for DGX Spark, so we assume 84% of its memory, the share macOS gives a 128 GB Mac. Checked 2026-10-19.

Reply speed

Writing each token reads the model's active weights once, so speed follows memory bandwidth: seconds per token = active GB / (bandwidth x 0.85) + a fixed cost per token of 2 ms on Apple for standard models, 5 ms for hybrid linear-attention models (Qwen3.5 and 3.8), 6 ms for mixture of experts; 1.3 ms on NVIDIA and DGX Spark for standard models and 2 ms for mixture of experts. Active GB comes from the file's tensor table where we computed it, else from a similar file of the same model whose table we read, scaled by file size, else from the active parameters at the file's own bits per weight. When a PC spills into system memory, that part reads at 60 GB/s x 0.6 (assumed dual-channel DDR5). Fitted to 53 published llama.cpp and MLX runs, it had a median error of 6% and every point within 20%; that fit is in-sample. AMD and Intel cards borrow the NVIDIA values and are marked rough. Speeds are at short context; long chats run slower. Checked 2026-10-19.

Why speeds are a range

The top of the range is the formula above. The bottom is 65% of it on M1 and M2 chips, where our own Mac app ran about a third under the formula on two mid-size models, and 85% everywhere else. The M1 and M2 rule rests on those two points only. Checked 2026-10-19.

When we do not estimate speed

We show no estimated speed for weights under 2 bits each, which are limited by computation rather than bandwidth (a 1‑bit 27B model ran at about a quarter of the bandwidth limit), or for mixture-of-experts models above 120B total parameters, where the formula ran 40% fast on Muse Spark Open against a measured 18 tokens per second. Those rows show measured speeds where someone published them, and "not measured" otherwise, and a model with no speed figure is graded Tight at best. Checked 2026-10-19.

Measured beats estimated

When someone published a speed for the same model, quant and chip, we show that number, labelled measured, with its source and caveats, instead of the formula. A run on another runtime (Meta's ExecuTorch numbers for a GGUF, for example) or one that does not say which GPU-core version of a chip it used is shown for comparison only. Our own measurements come from PocketWebTools for Mac on a 16 GB M1 Pro and a 32 GB Mac mini M4. A speed measured at a context more than 4 times shorter than the one you picked (or at an unstated one, which usually means a short test) is labelled measured at short context, since long chats run slower. Measurements of several Macs linked together never stand in for one Mac, and each is shown with its number of Macs. Model data checked 2026-10-19.

Grades

Won't fit: the model needs more than the GPU can use (plus the allowed system memory on a PC). Tight: it fits but needs more than 90% of that memory, spills into system memory, replies under 8 tokens per second, or has no speed figure for that machine. Runs well: everything else. Every grade states the quant, the context length (8,192 tokens unless you change it) and the memory figure it assumed. Speech, voice and image models are graded on memory only. Checked 2026-10-19.

Time to the first word

Reading your prompt is limited by computation, not bandwidth. We scale each chip's published llama.cpp prompt speed on a 7B model by 6.6B / the model's active parameters, x 0.75 for mixture of experts. It matched measured runs within 8% for standard models. Checked 2026-10-19.

Questions

Is my GPU NVIDIA or AMD?
The box at the top of this page shows the brand your browser reports. In Firefox you get the brand only, in Chrome and Edge the exact model, and Safari says only Apple GPU. On Windows you can also check Settings > System > Display > Advanced display.
How can I check how much VRAM I have?
Browsers cannot read video memory, so look it up: on an NVIDIA card, NVIDIA Control Panel > System Information lists it. Some cards, such as the GeForce RTX 4060 Ti, are sold with two memory sizes under one name, so the model name alone is not enough. On an Apple Silicon Mac there is no separate video memory: the GPU shares the Mac's memory.
What GPU does my Mac have?
On a Mac with Apple Silicon the GPU is part of the chip, so Apple menu > About This Mac answers it: it shows Chip followed by the chip's name. The GPU shares the Mac's memory; on macOS 26 and later a 16 GB Mac lets it use about 12.7 GB by default. An Intel Mac shows Processor instead; open this page in Chrome to read its GPU name.
How do I tell what GPU I have without plugging it in?
This page can only read the GPU of the computer it is open on. A card that is not installed has to be identified from its label or box.
How to check GPU and CPU info?
On a Mac, Apple menu > About This Mac shows the chip, which holds both the CPU and the GPU. On Windows, Task Manager > Performance lists the CPU and the GPU.
Is my GPU outdated?
For local AI, memory matters more than age. An 8 GB card runs an 8B model at 4‑bit with 8,192 tokens of context, though tightly: Qwen3 8B needs about 6.9 GB of the 7.5 GB an 8 GB GeForce RTX 4060 can use. A 14B model spills into system memory and slows down.

Where to go next

Sources

Updated Page published: reads your GPU in the browser, says what the browser hides, and hands the machine to the AI checker.