# GPU benchmark

> How the browser benchmark tests your GPU, how it decides good to go, tight or won't run for a workload, and what it keeps.

URL: https://gpuninja.com/docs/browser-benchmark
Last updated: 2026-10-10

## What it does

The GPU benchmark at `/benchmark` answers one question: can the GPU in this machine run the AI workload you have in mind? It runs a few short tests on your GPU, in your browser, and compares what it measures with what the workload needs.

You choose the workload in the workload planner, then follow its Test this workload on my GPU link. The benchmark opens with that workload, says which one it is judging, and links back to the planner so you can change it. You can also open the benchmark on its own, run the tests and enter your GPU's memory, then choose a workload in the planner: when you come back, the verdict appears without running the tests again.

The benchmark needs JavaScript and a browser with WebGPU: a recent version of Chrome, Edge, Safari or Firefox. Without WebGPU it can't test your GPU, but it can still tell you when a workload won't fit in memory.

## The tests

Press Run to start. Nothing runs until you do, because the tests work your GPU hard: they take about 5 seconds, and never more than 30. The dials show each reading as it comes in, and settle on the result when a test ends. You can cancel at any time, and the tests pause while the tab is hidden.

| Test             | What it does                                                                   | Reported in |
| ---------------- | ------------------------------------------------------------------------------ | ----------- |
| Memory bandwidth | Copies one large buffer, up to 256 MB, into another, again and again           | GB/s        |
| FP32 compute     | Runs long chains of fused multiply–adds in 32-bit floating point on every core | TFLOPS      |
| FP16 compute     | The same in 16-bit floating point, where your GPU and browser support it       | TFLOPS      |

Bandwidth counts every byte read and every byte written, the "copy" convention of the STREAM benchmark. Running a language model is mostly reading, so a copy that moves 400 GB/s in total reads about 200 GB/s.

Each test runs a short probe, a few warm-up rounds, and then nine timed trials. The result is the middle trial (the median), shown with the range of all nine. When the trials vary a lot, the table says so and suggests closing other apps and running again; the result is still used. Timing comes from the GPU's own timestamps when the browser offers them, and from the browser's clock otherwise, and the table says which.

A test can end without a figure:

| Shown                                     | Why                                                                                          |
| ----------------------------------------- | -------------------------------------------------------------------------------------------- |
| Not supported by this GPU in this browser | The browser doesn't offer 16-bit compute on this GPU                                         |
| Too slow to test safely                   | One round took longer than half a second, so longer runs could make the system reset the GPU |
| Not enough free GPU memory to test        | The browser couldn't allocate the test's buffers, even at 64 MB                              |
| The browser couldn't run this test        | The browser rejected the test's shader                                                       |
| Ran out of time                           | The run passed its 30 seconds, or a test couldn't get nine clean trials                      |

> Note:
> Results are measured in this browser. The browser checks every command it sends to the GPU, and the GPU is shared with everything else on the machine, so the figures read lower than a native benchmark and lower than the chip's specification. Don't compare them with the catalog's benchmark results, which are measured natively on a known platform.

## Your GPU's memory

Browsers can't see how much memory your GPU has. Chrome and Edge do tell the page your GPU's name, so the benchmark looks that name up in the catalogue and fills in the memory for it, saying where the number came from: the memory every card with that GPU has, or the largest it comes with. Check it, and change it if yours differs. The name is used on the page only, never stored or sent.

In other browsers, or when the catalogue doesn't have your GPU, start typing your card or chip in Find your GPU and choose it, or type the memory in GB. Choosing a chip fills in the largest memory that chip comes with; if your card has less, change the number.

On Apple silicon and other systems where the GPU shares memory with the rest of the machine, enter the memory the GPU may use, not the machine's total.

Without a memory size there is no verdict: the benchmark shows the measurements and asks for it.

## The verdict

The verdict compares the workload's estimate from the workload planner with your GPU's memory and the measured bandwidth. It is always a word, a shape and the reasons, with their numbers, never a colour alone.

| Verdict    | When                                                                                                                                                                                                                   |
| ---------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Good to go | The workload fits with room to spare, and the measured bandwidth meets its target speed with room to spare                                                                                                             |
| Tight      | It runs, but not as planned: only a shorter context, fewer sequences or a smaller batch fits (the verdict says the largest that does), little memory is left free, or the bandwidth leaves little or no speed to spare |
| Won't run  | It doesn't fit in memory even at its smallest                                                                                                                                                                          |

Room to spare in memory means at least 10% of your GPU's memory stays free, and never less than 1 GB, whatever the card. The desktop and the browser use the same memory as the workload, so a card of 1 GB or less is never good to go.

The smallest workable shape is one sequence with 2,048 tokens of context for running a model, and a micro-batch of one with activation checkpointing at 2,048-token sequences for fine-tuning (or the workload's own length, if shorter). Memory is the only reason a verdict says won't run.

Speed has two thresholds. The planner states what a workload reads at its target speed (its sustained bandwidth) and what a GPU's peak needs to be to deliver that (its required peak). Measured at or above the required peak, speed has room to spare. Between the two, it meets the target with little room. Below the sustained figure, expect it to run slower than planned. Either way that is tight, never won't run, because a browser measures lower than native apps.

Fine-tuning is judged on memory only. The measured compute figures are shown, but a browser understates them too much to predict a training time.

When a workload fits in memory but nothing has been measured yet, the verdict waits for a run: it can't be called good to go without one.

## What it keeps, and what it sends

Nothing the benchmark measures leaves your browser. No result, verdict, memory size or detail of your GPU is sent to GPU Ninja or anyone else, and none of them is put in a link, so a link you share carries only the workload.

The rounded measurements and the memory you entered are kept in your browser's session storage, under the key `gpuninja.benchmark`, so they survive the trip to the planner and back. The planner reads them and shows them beside its estimate. They are cleared when you close the tab, and the benchmark doesn't remember your GPU between visits. The browser's description of your GPU is shown on the page and never kept.

## Clearing and downloading results

Clear results removes the measurements from the page and from the tab, and keeps the memory you entered. Download results saves a JSON file on your own device, named by the time of the run, such as `gpuninja-benchmark-2026-10-10T21-15-00Z.json`. It holds the figures with their ranges and trials, your GPU as the browser describes it and the memory you gave, the workload and the verdict with its reasons, and it is tagged as measured with the GPU Ninja browser benchmark. The file is written by your browser to your device; nothing is sent.

## Versions

The tests, the method and the verdict rules carry one number, `BENCHMARK_VERSION`, shown in the results table and under How this works on the page, beside the estimator's version. It changes whenever any of them does, and measurements kept from another version are dropped rather than judged under new rules.