Device memory

The figure is coarse on purpose, so on its own it carries almost nothing. What makes it worth reading is the second number beside it: the memory ceiling of the page, which is derived from the first.

Device memory is the amount of memory a browser reports, rounded down to a power of two and never above eight.

What a page reads about memory

Two readings, taken in one line each and without permission. One is deliberately blunt and the other is fine enough to contradict it.

The rounded figure
A power of two, capped at eight however much the machine really has. Most desktops therefore answer four or eight.
The memory ceiling of the page
How much memory the page is allowed to fill. The browser derives it from the machine's memory, so it is a second opinion on the first number.
The pair together
A figure of four beside a ceiling that only a much larger machine would give is read in one comparison.
Where it is absent
Not every browser reports the figure at all, and its absence says which browser family you are in.

Your machine right now

These values are read in your browser on this page. Nothing leaves it and no request goes out with the reading.

Perangkat Anda, saat ini

Device memory: mengukur di perangkat Anda
Logical processors: mengukur di perangkat Anda
Platform: mengukur di perangkat Anda

Dibaca di peramban Anda dan ditampilkan di sini. Tidak ada yang dikirim ke mana pun.

The figure and the memory ceiling

The ceiling is not a free number. A browser takes it from the memory of the machine: half of it on a sixty four bit desktop and a quarter on a phone, with a floor of two hundred and fifty six megabytes and a top of four gigabytes.

It is never handed over exactly either. The value lands on one of a hundred steps between ten megabytes and four gigabytes, and the highest step is below four gigabytes, so that round figure is never what a page sees.

The rule comes from the engine itself
The divisor and the bounds are read out of the browser source rather than guessed, because guessing here creates the very mark it was meant to remove.
The hundred steps are reproduced
They are computed the way the engine computes them and compared against a table taken from its own code, step by step.
Both shapes of answer are legal
A page gets the exact number in some cases and the step in others, and a check that demanded one would fail on a healthy build.

What our engine does

The figure arrives as one seed on the launch line, before the first line of page code runs, and it is drawn from what machines with the profile's graphics card report.

The ceiling is then brought into line with that figure. Where the declared figure already agrees with the machine, nothing is changed at all.

1
The figure follows the card
Cores, memory and graphics are one description of one machine, and all three come from the same profile seed.
2
The choice stays narrow
Four and eight are what the editor offers, because those are the figures this population of machines reports.
3
The ceiling is derived not stored
It is recomputed from the figure on every launch, so the two can never drift apart between sessions.

What the shipping build answers

Two measurements from the acceptance run of the build shipping today, on a Windows profile whose seed asked for eight.

The figure matched the seed
Measured on a build host that has a different amount of memory to the one the profile claims.
8
The ceiling followed the figure
The page was allowed four thousand one hundred and ninety two megabytes against about four thousand one hundred and thirty six expected.
within the margin

How to check your own

The panel above shows what this browser reports. The free check on this site puts the figure and the core count on one row, which is how a site reads them.

Inside the app the self-test runs in a profile against the engine that profile launched. It compares the figure to the seed and then measures the ceiling the page was given.

What this does not do

It does not add memory to your computer. A figure far from what the machine has makes a profile easier to spot, because the memory ceiling of the page is derived from that figure and the two are read together.
It does not offer a rare figure. Four and eight are the choice, because the browser rounds down to a power of two and stops at eight, and a smaller figure would stand apart from every profile the app hands out.
It does not hide memory pressure. A tab that runs out of memory runs out on the real machine, whatever figure the page was told.
It does not make a profile anonymous. Behaviour, address reputation and account history close more accounts than any hardware reading does.

Check it

Every number above comes from a file you can open.

The memory checks the self-test runs: apps/desktop/src/lib/fpAudit.js
Where the figure and the ceiling come from: packages/shared/src/index.js
The hundred steps match the engine to the unit: packages/shared/test/ступени-памяти-как-у-движка.js · docs/замеры/ступени-памяти-153.cc
The acceptance run quoted above: engine/приёмка-отчёт.json

Questions

Why is eight the highest figure?: Because the browser stops there however much memory the machine has. A profile claiming more than eight contradicts the browser it says it is, and that contradiction is one comparison away.
Can a page work out my real memory?: Not the exact amount. It can read the memory ceiling of the page, which follows the reported figure, and in a profile both come from the same seed.
Does a larger figure make a profile safer?: No. The ceiling has to follow the figure, so a number far from the machine gives a site two readings that disagree instead of one that is quietly ordinary.
Do two profiles report different memory?: Often they report the same, because the honest range is narrow. What separates two profiles is the set around the figure: the cores, the card, the screen and the fonts.

Next to this

See what your own profile answers

The self-test runs inside a profile and shows all 29 measurements, green and red alike.

Download ARMANOS All features