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

Rubric 1.0.0 · column 5 of 13

CPU cores

navigator.hardwareConcurrency — the number of logical processors the browser is willing to admit to.

Under rubric 1.0.0 this column is worth between 1.84 and 6.64 bits, and the likeliest outcome the table knows — 8 — costs 1.84. 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 core count

The browser asks the operating system how many logical processors it can schedule work on and returns that count, which is threads rather than physical cores on any machine with simultaneous multithreading. Chromium clamps what it is willing to report on some platforms, so the number arriving in the page has already passed through a vendor decision before anybody tries to spoof it. Its real purpose is capacity planning for worker pools, which is why it is available without permission at all.

How rubric 1.0.0 prices a core count

Nine explicit counts and a tail. 8 is assumed at 0.28 and costs 1.84 bits, 4 is 0.22 and 2.18, 12 is 0.13, 16 is 0.12, and 2 and 6 share 0.07. From there it thins: 10 at 0.04, 20 at 0.03, 24 at 0.02, and anything else — 5, 14, 128 — sits at 0.01 for 6.64 bits. The buckets follow powers of two because that is what the hardware ships as, not because the distribution was measured.

The spread between the cheapest and the dearest outcome is 4.81 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 cores has.

Outcome Assumed p −log₂p
8 modal outcome — the printed line 0.280 1.84
4 0.220 2.18
12 0.130 2.94
16 0.120 3.06
2 0.070 3.84
6 0.070 3.84
10 0.040 4.64
20 0.030 5.06
24 0.020 5.64
5 any count not on the rule's list 0.010 6.64

What changing a core count costs

Core count sits in the capability group with device memory and touch points, so unless it is the loudest of the three it is charged at 35% and the whole column is worth well under a bit to you. Reporting 8 instead of 5 saves 4.80 raw bits before discount and very little after it. What it can cost is credibility elsewhere: a machine claiming 4 threads that renders a complex canvas in a timing an anti-bot vendor can compare against is telling two stories.

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

The rubric's own reasoning, verbatim

hardwareConcurrency clusters on powers of two. Chromium also caps the reported value, which compresses the tail.

What moves it

The hardware, or a spoofer. Chromium caps the reported value on some platforms, so the browser is already lying a little before anyone intervenes.

Where this prior is weakest

The prior assumes a desktop distribution. On mobile the shape is different, and this rule does not know which it is looking at — it reads the same table either way.

Correlation

Grouped with Device memory and Touch points under "capability". 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 cores →


What people ask about a core count

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 my browser report fewer cores than my CPU has?
Chromium caps the value it reports on some platforms, and the figure counts logical processors rather than physical cores in the first place. The number in the page has already been shaped by the browser vendor before any tool touches it.
Is an odd core count rare?
The rubric assumes so. Nine counts have explicit priors and everything else shares 0.01, so a reported 5 costs 6.64 bits while a reported 4 costs 2.18 — a gap produced entirely by which numbers made the list.
How much does changing my core count actually save?
Usually a fraction of a bit. This column lives in the capability group, and if device memory or touch points carries more surprisal in that pass, the core reading is multiplied by 0.35 before it reaches the total.

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 ↗