Agreement inside one fingerprint

A platform rarely reads one value. It reads several at once and asks whether they could belong to the same machine, which is why a single corrected reading can be louder than no correction at all.

What a platform reads together

A fingerprint is not one answer but a set of them. A platform asks a simpler question than which value is rare: whether these values fit one machine.

A rare value on its own is only a rare value. A pair that no machine has ever produced is an answer.

Graphics card and architecture
A card sold for one processor family next to an architecture hint belonging to another.
Screen and pixel ratio
Multiply one by the other and the result has to be a panel somebody actually makes.
Latency and connection type
The browser derives the type from the latency, so a pair that disagrees came from elsewhere.
Declared memory and the heap limit
The limit a page can read is one the browser computes from the memory the machine reports.

How the set is drawn here

There is no finished device sitting on disk. A profile builds it again at every launch from its own settings, so one profile is one machine and two profiles are two different ones.

The parts are chosen to fit each other rather than one by one. Cores and memory a profile takes from the family its graphics card belongs to, and on a phone profile the screen, the ratio, the card and the fonts all come from one handset.

Values taken from the browser's rules

Some readings are not free to invent. A real browser rounds the round trip time, caps the downlink and derives the connection type from both, so a plausible looking number it never returns would give a profile away on the first check.

The same holds for the heap limit a page reads. It follows the memory the profile declares.

Round trip time and downlink
Rounded and capped the way the engine rounds and caps them, not the way they look plausible.
Connection type
A profile derives it from the latency rather than drawing it, because a real browser derives it too.

Eight ways along one axis

Read the table as scope rather than as a score. A way of working is not worse for leaving alone what it never promised to touch.

The last row is ours, and you can check every cell in it: each one comes either from code you can open or from a measurement on the finished engine.

	What changes in the readings	What keeps the parts agreeing	Where such a set contradicts itself
An ordinary browser as it is	Nothing	The machine itself	Nowhere: it is one honest machine
Incognito	Nothing in the device readings	The machine itself	Nowhere in the device
Separate profiles of the same browser	Nothing in the device readings	The machine itself	Nowhere in the device
An extension that swaps values in the page	The properties on its own list	Whoever wrote that list	Where the same thing is read by a second road
A VPN	The exit address only	Nobody: the device is untouched	Between the country of the exit and the clock of the machine
A virtual machine per account	The whole guest system	The guest system itself	Inside the guest they agree, and the guest is one machine for every account in it
Separate hardware per account	Nothing: it is a second machine	The machine itself	Nowhere
A browser with the engine itself changed	The whole set, derived from the profile's number	The generator draws the device as one machine	Checked by relationships rather than by values

Reading it back in the browser

Agreement on paper is not agreement in a window. We read every value back inside a real profile, including from an invisible frame and a background worker, and no build reaches you without that.

A shorter version of the same reading runs on this site. It asks your own browser the same questions and sends nothing anywhere.

The engine screen in ARMANOS: a choice between the built-in Chromium and an installed ARMANOS Browser, with version numbers and the path to the build it found — Profiles start on whichever build is selected here, and the values are read back from that same build.

What this comparison does not claim

It does not claim that a device agreeing with itself keeps an account. Behaviour, payment details and the history of the account are read as well, and no browser touches those.
It does not describe any named product. These are ways of working, and what somebody else's build does is not ours to measure.
It does not claim to know what each platform checks. Nobody publishes that, and the pairs above are simply the ones a browser has to keep straight on its own.
Not every reading is answered inside the engine yet. What a build does not declare is still corrected from the page.
The acceptance figures come from one build on one machine. Another build and another machine give other rows.

How to check this

Every statement above has a file behind it, and most have a stand that runs the code rather than reading it.

The whole device is derived from the profile's number, and the parts are drawn from each other: packages/shared/src/index.js
Agreement is asserted by running the generator over hundreds of profiles, not by reading the source: apps/desktop/test/fingerprint-consistency.js
Every value is read back inside a running browser, including from a frame and a worker: apps/desktop/src/lib/fpAudit.js · apps/desktop/test/fp-audit.js
The acceptance run of the built engine records what it expected and what it read: engine/приёмка-отчёт.json

Questions

Why can one corrected value be worse than none?: Because the correction has to agree with everything left untouched. A value no real browser returns, or a second road to the same picture that disagrees with the first, is an answer rather than a guess.
Does a profile get a new device after an update?: No. A profile keeps the generation it was created under, and a wider pool of machines is offered to new profiles instead.
What happens to a value I pick by hand?: It wins over the draw. A value that does not belong to the chosen template is dropped, and the app tells you what it dropped rather than leaving a pinned value on screen that no longer applies.
Can I look at my own values first?: Yes. The check on this site reads 12 values in your own browser and sends nothing anywhere.

Read your own values first

The check reads 12 values in your browser and sends nothing anywhere.

Open the check All comparisons