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.
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
- The prior for device memory — the other reading the capability group discounts this one against.
- The prior for touch points — the other reading the capability 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.