Fingerprintscore Chart form FS-1 Rubric 1.0.0 Priors: assumed · Counts: real Donut Browser ↗

Rubric 1.0.0 · column 10 of 13

Canvas rendering

A hash of the pixels this browser produces for a fixed drawing operation. It is a function of the whole rendering stack, not of any one component.

Under rubric 1.0.0 this column is worth exactly 8.97 bits to every browser the rule can read. There is no likelier or unlikelier outcome, because the rule assigns one prior to every value it can return. 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 a canvas hash

A fixed drawing instruction — some text, some shapes, a gradient — is rasterised and the resulting bytes are hashed. Nothing about that pipeline is standardised at the pixel level: the GPU, the driver version, the platform text rasteriser, the anti-aliasing strategy and the fonts available to fall back on all contribute, and any one of them changing changes the hash. That is why it is one of the oldest fingerprinting surfaces on the web, and why it is grouped with the renderer string that helped produce it.

How rubric 1.0.0 prices a canvas hash

One outcome. Rubric 1.0.0 assigns a prior of 0.002 to every canvas hash without exception, which is 8.97 bits for anybody who has one — the largest single reading this table can produce, handed out identically to everyone. The envelope printed on the chart form is therefore a point, not a band, and the margin says so beside it. This rule cannot distinguish a hash shared by millions of identical stock machines from one that nothing else on earth would produce.

The spread between the cheapest and the dearest outcome is zero — every reading this rule can produce costs the same, which is why its printed envelope is a point rather than a band. 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 canvas has.

Outcome Assumed p −log₂p
b41c9f2e77a0… every canvas hash, without exception modal outcome — the printed line 0.0020 8.97

This envelope collapses to a single point: the rule assigns the same prior to every possible value, so it produces 8.97 bits for everyone who has one. That is an artifact of a coarse rubric, it is drawn on the form rather than hidden, and it is the first thing a measured table would fix.

What changing a canvas hash costs

There is no cheaper reading to move to — every hash costs 8.97 bits — so the only thing to change is whether a hash exists at all. Blocking the readback removes the column and makes the renderer string the dominant member of the graphics group. Injecting per-read noise produces a value that differs between two reads seconds apart in one session, which the stability re-read on this site compares directly and which no honest browser does.

Every column ranked by how much it can move a total →

The rubric's own reasoning, verbatim

The rendered pixels depend on GPU, driver, OS text rasterizer and installed fonts together. Highly identifying, and heavily correlated with the GPU signal — which the group discount handles.

What moves it

Anything that changes rendering: a driver update, a font installation, a different GPU. Per-read noise injection changes it every time it is read, which is detectable by comparing a browser to itself.

Where this prior is weakest

Every possible value carries the identical prior of 0.002, so this rule's envelope collapses to a single point at 8.97 bits. It cannot tell a common hash from a unique one, and it never claims to. It is the clearest example on the form of a coarse rule being drawn rather than described.

Correlation

Grouped with GPU renderer 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 canvas →


What people ask about a canvas hash

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 does every canvas hash score 8.97 bits?
Because the rule assigns the same prior of 0.002 to all of them. It is the one column whose printed envelope is a single point rather than a range, and that flatness is drawn on the form rather than described in a footnote.
Does canvas noise injection help my score?
Not on this form, since every hash is priced identically. It also makes the value differ between reads within one session, which is a comparison a browser can run against itself and which needs no population at all.
What actually changes my canvas hash?
A different GPU, a driver update, a font installation, or a change in the platform text rasteriser. It is a function of the whole rendering stack, which is why rewriting the readback function does not change what produced it.

Where to read next

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.

Download Donut Browser Source on GitHub — AGPL-3.0 ↗