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.
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
- The prior for GPU renderer — 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.