Rubric 1.0.0 · column 9 of 13
GPU renderer
The unmasked WebGL renderer string, such as ANGLE (NVIDIA, NVIDIA GeForce RTX 4070 Direct3D11 vs_5_0 ps_5_0, D3D11). Thousands of distinct strings exist.
Under rubric 1.0.0 this column is worth between 5.64 and 8.64 bits, and the likeliest outcome the table knows — Google SwiftShader — costs 5.64. Those figures are assumptions printed before your run. The counted box beside them is not: it is how many of the devices these sites have read share your value.
How a browser produces the GPU renderer string
A WebGL context asks its driver to identify itself, and on Chromium the answer arrives through ANGLE, the translation layer between WebGL and the platform graphics API. The string that comes back names the vendor, the adapter, the backend — Direct3D11, Metal, Vulkan — and often the shader model, because ANGLE composes it from the driver response rather than from a fixed list. It is the same driver that will shortly rasterise the canvas, which is exactly why these two columns are grouped.
How rubric 1.0.0 prices the GPU renderer string
Two outcomes, and the collapse is deliberate rather than hidden. A string containing SwiftShader or llvmpipe — a software rasteriser, which normally means no GPU is available or none was exposed to the process — is assumed at 0.02 and costs 5.64 bits. Every other renderer string is assumed at 0.0025 and costs 8.64 bits, the highest reading of any non-degenerate rule in the table. A GeForce RTX 4070 and a rare workstation card price identically.
The spread between the cheapest and the dearest outcome is 3.00 bits, and that spread is the whole of what this column can ever do to a total. Where the four band edges sit →
Every outcome this rule can produce
This is the printed envelope, written out. The pen cannot land outside it, because these are
all the answers rule gpu has.
| Outcome | Assumed p | −log₂p |
|---|---|---|
| Google SwiftShader any software renderer modal outcome — the printed line | 0.020 | 5.64 |
| ANGLE (NVIDIA, NVIDIA GeForce RTX 4070 Direct3D11 vs_5_0 ps_5_0, D3D11) any hardware renderer string | 0.0025 | 8.64 |
What changing the GPU renderer string costs
This is the column where the difference between rewriting a value and changing it is most visible. Overwriting the renderer string in the page takes one line and moves 3 bits at best, since both outcomes are expensive. What it cannot do is change the pixels the real driver produces for the canvas rule sitting next to it in the same group. Claiming a software rasteriser while returning hardware-accelerated pixels is a claim the machine immediately falsifies.
The rubric's own reasoning, verbatim
The single highest-entropy stable signal in a normal browser. The renderer string names the driver, the adapter, and often the exact backend, and there are thousands of distinct strings.
What moves it
A different GPU or driver. JS-level spoofing rewrites the string but leaves the rendered pixels produced by the real driver, so the canvas signal and the renderer string stop agreeing.
Where this prior is weakest
This rule has exactly two outcomes — hardware or software renderer — so a GeForce RTX 4070 and a rare workstation card price identically at 8.64 bits. That is the coarsest treatment of the strongest signal in the table, and the printed envelope shows it as a two-value collapse rather than hiding it.
Correlation
Grouped with Canvas rendering under "graphics". Whichever of them carries the most surprisal in a given pass takes full weight; the others take 35%. The chart draws the short stroke rather than describing it.
How the correlation discount works →
Challenge it
If you have a source that contradicts this assumption, the honest thing is to say so in
public against this specific prior. Open a challenge
against gpu →
What people ask about the GPU renderer string
Answered from rubric 1.0.0 itself. Where an answer quotes a probability, that probability is a constant in the shipped scoring code and is printed in the table above.
- Why is every hardware GPU worth the same number of bits?
- Because rubric 1.0.0 tests the renderer string for a software rasteriser and prices everything else at a flat 0.0025. The rule has two outcomes, not thousands, and the printed envelope on the chart form shows that collapse as two points rather than a range.
- Does blocking WebGL lower my uniqueness score?
- It removes the column: with no renderer string the rule returns null and the pen lifts. That takes 8.64 bits out of the sum and replaces them with a browser that refuses a capability almost every real browser has.
- Why is a software renderer cheaper than a real GPU?
- The rule assumes software rasterisers at 0.02 against 0.0025 for everything else, so SwiftShader costs 5.64 bits instead of 8.64. Reporting one is also what a headless container looks like, which is a trade this form does not price.
Where to read next
- The prior for canvas rendering — the other reading the graphics group discounts this one against.
- The complete prior table for all 13 columns — every rule, every outcome, and the rationale the rubric ships with each one.
- Assumed and counted: what a prior is, what the counted column beside it measures, and why the two are never added.
- Compare two passes for the delta on this column — change one setting and read what actually moved, instead of guessing from a total.
Where the pens move
Knowing which prior is weak is only useful if something can actually move the signal.
Engine level, not JS level. Donut Browser spoofs through CDP injection in its Wayfern Chromium fork, so the value a page reads is the value the engine reports — there is no patched accessor to catch.
It refuses to contradict itself. A profile whose proxy exit geography, time zone or language disagrees with its fingerprint does not launch. That is a pre-launch gate in the app, not advice in a manual.
Open, and quiet. AGPL-3.0, desktop app and sync server both in the repository, and no analytics SDK anywhere in the source. macOS, Windows, Linux.