Which pens actually move
The two dearest columns on this form are canvas rendering at 8.97 bits and GPU renderer at 8.64, and neither is reported by an accessor — both are produced by the rendering stack. The dearest one you can simply set is language preferences, at 8.38. That gap is the whole shape of the problem.
The table below is every rule sorted by the most it can contribute under rubric 1.0.0, with what moves it. Read it top-down and stop caring somewhere around the four-bit mark, because everything below that is grouped, discounted, or worth less than the contradiction you risk creating while changing it.
| Signal | Max bits | Modal | What moves it |
|---|---|---|---|
| Canvas rendering | 8.97 | 8.97 | 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. |
| GPU renderer | 8.64 | 5.64 | 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. |
| Language preferences | 8.38 | 1.56 | Browser language settings. Emptying the list entirely does not help: an empty navigator.languages is itself an automation indicator that this site's sibling tools flag. |
| Screen resolution | 7.97 | 2.18 | Resizing a window does not move it — this is the screen, not the viewport. A different monitor, a spoofed screen size, or a change in OS display scaling does. |
| Time zone | 7.38 | 4.32 | The system clock setting, or a browser that overrides it to match a proxy exit. Overriding it without matching the proxy exit produces a contradiction, which is a worse outcome than a rare zone. |
| Color depth | 6.64 | 0.09 | Almost nothing. HDR and wide-gamut displays report 30 on some platforms, and some privacy tools normalise it to 24. |
| CPU cores | 6.64 | 1.84 | The hardware, or a spoofer. Chromium caps the reported value on some platforms, so the browser is already lying a little before anyone intervenes. |
| Audio sample rate | 6.64 | 0.47 | Audio hardware, or an OS-level output device change. Some anti-detect tooling normalises it, which usually means setting it to 48000 and losing whatever it was. |
| Touch points | 6.64 | 0.56 | The hardware. Touchscreen laptops report non-zero on Windows and confuse anything that treats this as a mobile test. |
| Operating system | 5.64 | 0.69 | Almost nothing you do in a browser moves this. Changing the UA string moves it immediately and moves nothing else, which is exactly the pattern a consistency check looks for. |
| Device pixel ratio | 5.64 | 1.00 | Changing the OS display scale moves it. Browser zoom moves it too on many engines, which is worth knowing before you conclude a tool changed something. |
| Device memory | 5.64 | 0.86 | Very little. The value is quantised so hard that a 128 GB workstation and a 8 GB laptop report the same number. |
| Installed fonts | 5.64 | 1.74 | Installing or removing fonts. Design and development machines carry far more than a stock install, which is why this signal separates professionals from everyone else so cleanly. |
The three that ignore a patched accessor
Canvas. The value is the pixels the rendering stack produced. You can
overwrite toDataURL, but you are then returning a value that no longer follows
from the GPU string you are also reporting — and the two are grouped precisely because they
are supposed to agree.
GPU renderer. Rewriting the string is trivial. Making the pixels match the string you rewrote it to is not, because those pixels come from a real driver.
Fonts. The count comes from text metrics, not from an enumeration API, so there is no single list to patch. Every measurement is a real rendering decision made by the system.
The trap in the middle of this page
Every signal above can be made rarer as easily as commoner. Emptying navigator.languages takes it out of the sum here — and puts an empty language
list into the automation indicators every anti-bot vendor checks first. Lowering a number on
this form is not the same as looking ordinary.
What actually reduces the trace
Two things, in this order. First, stop contradicting yourself: a proxy exit in Frankfurt
with an America/New_York time zone and an en-US language list is
three signals telling three different stories, and no bit count on this form captures how
bad that is.
Second, change the values at the level that produces them. A value spoofed at the engine is the value every path reads — the accessor, the worker, the second read three seconds later, and the pixels. A value spoofed by a patched function in the page is the value one path reads.
You can watch the difference on the chart form directly: take a pass, change one thing, press ADVANCE, and read the per-signal delta. The comparison view keeps both traces on one stock. The pens that refuse to move under a JS-level tool are the honest answer to what that tool is doing.
The site also offers a three-read stability check beside the chart: canvas, WebGL renderer and audio sample rate read three times within one session. If any of them changes between reads seconds apart, it is being generated rather than reported — which is itself a detectable pattern, and one that per-read noise injection produces by design.
Why the arithmetic disappoints people
Three mechanisms eat the savings, and all three are printed on this site rather than discovered later. The first is the correlation discount: a column that was not the loudest in its group was already being charged at 35%, so a five-bit improvement on it reaches the total as 1.75.
The second is the coarseness of the table. Several rules have two outcomes, so there is no gradual improvement available — the canvas rule prices every hash identically at 8.97 bits, which means no canvas value is better than any other and the only change available is whether a hash exists at all.
The third is that a rule which declines to read contributes nothing, so removing a signal removes its bits, and that looks like an improvement while being a distinctly odd browser. A machine with no WebGL, no canvas readback, no audio context and an empty language list scores beautifully here and looks like nothing that exists.
A sequence that is worth the effort
Take a baseline first. Run the form once and keep the stub. Without it, every subsequent judgement about whether something moved is a memory of a number.
Fix contradictions before rarity. The proxy exit country, the time zone and the language list are one claim told three times. This rubric prices each of them separately and cannot see the disagreement at all, which is a limitation of the rubric, not permission to leave it.
Then spend on the graphics group. It carries the two dearest columns, and it is the group where the difference between a rewritten value and a changed one is visible in a single pass: rewrite the renderer string and the canvas pixels stay exactly where they were.
Re-run and read the delta, not the total. The comparison view keeps both traces on one form. An edge crossing takes eight bits, so if you were expecting one, check the per-column figures before concluding the tool did nothing.
Questions about lowering a uniqueness score
Answers refer to what this rubric prices. Where an answer talks about detection rather than rarity, it is describing what this form cannot see.
- Does a lower score make me harder to identify?
- Not on its own. A rare-but-consistent fingerprint is often less interesting to an anti-bot vendor than a common one that contradicts itself, because a contradiction is evidence of intent in a way rarity never is.
- Why did changing my user agent barely move the total?
- Because the platform rule is worth about 0.7 bits for Windows and 2.5 for macOS, and it is grouped. Meanwhile the same change can put your declared OS at odds with your GPU string, which costs you far more than the bits it saved.
- Which signal should I change first?
- Whichever one your derivation shows carrying full weight and a large raw figure — usually the graphics group. Changing a column that was already discounted to 35% returns about a third of the bits you expected, and changing one the rule declined to read returns nothing at all.
- Can a browser extension lower my uniqueness score?
- It can change values that are read through JavaScript accessors, which is most of the table but not the parts produced by rendering. It cannot change the pixels a real driver rasterises for the canvas rule, and an extension that patches an accessor leaves the patched function itself visible to anything that inspects it.
- Why do some columns refuse to move no matter what I change?
- Because their value is produced rather than reported. The canvas hash comes out of the rendering stack, the font count comes out of text measurement, and the renderer string comes from the driver. A tool operating inside the page can overwrite what those functions return; it cannot change what produced them.
- Is the lowest possible score the goal?
- No, and treating it as one is the trap this page exists to describe. Emptying your language list removes a column here and produces an empty navigator.languages, which is one of the oldest automation indicators there is. Coherence is the goal; the bit count is a way of seeing which parts of your stack are real.
Where the pens move
Engine-level spoofing moves the pens a patched accessor cannot reach.
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.