GPU artefacts. A chip checked against itself.
Three checks through WebGPU, each with an exact answer. 30 seconds of integer hash chains on 4,194,304 words, every dispatch's checksum compared with one worked on the processor; up to 2,048 MiB of graphics memory written with three patterns and verified on the chip; and a fixed scene rendered 600 times and compared with its first frame. Any difference is an error.
Illustrative figures, not a measurement. The test reports your own.
Compute
4,194,304 words x 64 rounds, 30 s
Memory
Up to 2,048 MiB, 2 passes of 3 patterns
Render
600 frames at 512 px
Verdict
Any error fails
Exact answers, compared exactly.
A chip that is overheating, overclocked past what it holds, or losing bits in its memory often still runs; it just gets some answers wrong. This test asks for answers that have only one right value and counts the wrong ones.
- The known answer
- Each of 4,194,304 words starts from a fixed seed and its own index and goes through 64 rounds of xorshift32 plus a constant. It is integer arithmetic only, so every correct chip gives the same bits. The page works the checksum (the wrapping sum and the XOR of every word) once in JavaScript.
- The dispatches
- For 30 seconds the chip clears its buffer, runs the chain, reduces the buffer to a checksum on the chip, and hands back eight bytes. Each checksum is compared with the known answer; a mismatch is a compute error, and the first failing dispatch is named.
- The memory
- Buffers of 256 MiB, or the browser's binding limit if smaller, are allocated one at a time until 2,048 MiB or the first refusal. Each pass writes walking ones, every word's own address and a seeded random word into all of them, then a shader re-derives each word and counts mismatches on the chip. 2 passes.
- The frames
- 2,000 blended triangles placed by a hash, with no clock in the scene, drawn 600 times to an offscreen 512 by 512 texture. Each frame is hashed on the chip and compared with the first. The chip is compared with itself, because two drivers may draw the same scene legitimately differently.
Errors per part, and what was tested.
No score. Each part reports its error count beside the work behind it, so a zero means something. The verdict line is ours and it is zero: these outputs are exact by construction, so one difference fails the run.
Compute errors
Dispatches whose checksum differed from the known answer, out of the dispatches run, with the first failing one named.
Memory errors
Words read back different from what was written, summed over every sweep, with the MiB tested and the reason allocation stopped. The figure is the memory this browser allowed the page, never the card's size.
Render artefacts
Frames whose hash differed from the first frame's, out of the frames rendered, with the first differing frame named.
Duration and adapter
The active time the run took, and the adapter's own name for itself from adapter.info, or not reported when it gives none. A fallback adapter, which runs on the processor, is flagged.
Illustrative figures, not a measurement. The test reports your own.
Hardware
What it needs. Three tiers, no fine print.
Minimum
A browser with WebGPU
Chrome or Edge 113 or later on Windows, macOS and ChromeOS; Safari 26; Firefox 141 or later on Windows. Firefox elsewhere and older Safari report not supported.
Recommended
The chip warm, the way it fails
Artefacts from heat or an overclock show under load. Run it after a game or a stress run, not straight after boot.
Optimal
Plugged in, tab in front
A hidden tab pauses the run and the result says so. Close other programs using graphics memory, so the browser can hand the page more of it.
Questions
GPU artefacts, answered
- What does a GPU artefact test check?
- Whether the graphics chip gives the right answer to work that has exactly one right answer. It checks 30 seconds of integer compute against a checksum worked on the processor, graphics memory against patterns it wrote, and a fixed scene against its own first frame. Any difference is counted as an error.
- Does it test all of my VRAM?
- No. It tests what the browser lets a web page allocate, up to 2,048 MiB, and the result says how much that was: "tested N MiB of the memory this browser allowed". The rest of the card's memory, and anything the driver keeps for itself, is out of reach. It never claims the card's memory size.
- What does it mean if it finds errors?
- That the chip gave a wrong answer to exact work during this run. Common causes are overheating, an overclock or undervolt it cannot hold, failing graphics memory, or a driver fault. The test cannot tell which. Run it again with the case cool and any overclock removed; errors that stay are worth taking further.
- Does no errors mean my GPU is healthy?
- It means this run saw no errors in the work it did. A fault that appears only at a temperature this run did not reach, in memory the browser did not hand out, or below the driver where a page cannot see, would not show here. A clean run is evidence, not a guarantee.
- Why compare frames with the first frame and not a reference image?
- Different chips and drivers may draw the same scene with legitimately different rounding, so a stored picture would flag healthy hardware. A healthy chip drawing a scene with no clock in it gives the same bits every time, so the test compares the chip with itself.
- Why does it say not supported?
- The browser has no navigator.gpu. Firefox has WebGPU on Windows from version 141, Safari from version 26, and older versions of either have none. Without it there is no way for a page to run this check, so the page says so rather than guessing.
- Is this part of the main SystemCheck run?
- No. It runs on this page only and does not change the score or the report. The main run's graphics stages use WebGL2; this check uses WebGPU compute, which not every browser has.