Rubric 1.0.0 · column 6 of 13
Device memory
Reported RAM in gigabytes, rounded down to a power of two and capped at 8 by the specification itself.
Under rubric 1.0.0 this column is worth between 0.86 and 5.64 bits, and the likeliest outcome the table knows — 8 GB — costs 0.86. 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 the device memory value
This is the one signal in the table that was quantised on purpose by the people who specified it. The Device Memory API rounds the machine's installed RAM down to the nearest power of two and then clamps the result to a maximum of 8, precisely so that it cannot be used to separate a 16 GB laptop from a 128 GB workstation. Firefox and Safari declined to implement it at all, so on those engines it does not have a low value — it has no value.
How rubric 1.0.0 prices the device memory value
Six outcomes, heavily weighted toward the ceiling. 8 GB is assumed at 0.55 and costs 0.86 bits, 4 at 0.25 and 2.00 bits, 2 at 0.10, 1 at 0.05, 0.5 at 0.03, and anything else at 0.02 for 5.64 bits. Because the API caps at 8, the commonest reading is also the specification maximum, and this rule is worth less than a bit to most of the machines it reads.
The spread between the cheapest and the dearest outcome is 4.78 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 memory has.
| Outcome | Assumed p | −log₂p |
|---|---|---|
| 8 GB modal outcome — the printed line | 0.550 | 0.86 |
| 4 GB | 0.250 | 2.00 |
| 2 GB | 0.100 | 3.32 |
| 1 GB | 0.050 | 4.32 |
| 0.5 GB | 0.030 | 5.06 |
| 0.25 GB any value not on the rule's list | 0.020 | 5.64 |
What changing the device memory value costs
Almost nothing is available to save, which is what makes this column interesting in reverse. Reporting a value on an engine that has no such API — a Firefox user agent that nonetheless answers navigator.deviceMemory — costs you nothing on this form and hands a vendor a clean contradiction. The absence of this signal on Firefox and Safari is the expected state, not a gap to fill.
The rubric's own reasoning, verbatim
navigator.deviceMemory is deliberately coarse and caps at 8, so it carries little information by design. Weighted accordingly.
What moves it
Very little. The value is quantised so hard that a 128 GB workstation and a 8 GB laptop report the same number.
Where this prior is weakest
Firefox and Safari do not implement it at all, so this rule declines to read on a large share of real browsers — and a declined rule is not a zero, it is an absence. That absence is arguably itself a signal, and this rubric does not price it.
Correlation
Grouped with CPU cores 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 memory →
What people ask about the device memory value
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 is device memory missing from my derivation?
- Because your browser does not implement navigator.deviceMemory. Firefox and Safari never shipped it. The rule returns null, the pen lifts, and the column is excluded from the sum rather than counted as zero bits.
- Why does my 32 GB machine report 8 GB?
- The specification rounds down to a power of two and caps the result at 8 deliberately, to stop the value separating high-memory machines from ordinary ones. The cap is the whole design, not a browser bug.
- Should an anti-detect profile report device memory at all?
- Only when the engine it claims to be would report it. A user agent that names Firefox alongside a working deviceMemory value is a contradiction that costs nothing in bits and is trivially checkable.
Where to read next
- The prior for CPU cores — 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.