Wala pa ang pahinang ito sa inyong wika. Binabasa ninyo ang tekstong Ingles.
Glossary
WebGL renderer string
A WebGL renderer string is the line a browser returns for the chip, the driver and the graphics layer that drew a frame.
What one line carries
The line is a report rather than a name. A graphics layer, a maker, the chip itself and the shader levels it supports all sit in one string, and the shape of that string differs by platform.
That is why a line copied between platforms is wrong at a glance. The three shapes below are the ones a real machine produces.
Windows
The line names the Direct3D layer and the shader levels it reaches, and carries the device identifier of the chip in brackets.
macOS
The line names the Metal renderer and the chip family behind it, and says nothing about a driver version.
Linux
The line goes through Mesa and names the driver stack with an OpenGL level, so a Direct3D line there belongs to no machine.
Your renderer string right now
This is the line your current browser hands to any page that asks for it. It is usually enough on its own to name the chip and the layer beneath it.
Nothing here leaves the page. The reading is taken on the spot and no request goes out with it.
Ang inyong makina, ngayon mismo
- WebGL renderer
- sinusukat sa inyong makina
- WebGL vendor
- sinusukat sa inyong makina
- Platform
- sinusukat sa inyong makina
- Device pixel ratio
- sinusukat sa inyong makina
Binasa sa inyong browser at ipinapakita rito. Walang ipinapadala kahit saan.
What the chip decides
A chip is not a free choice. Naming one commits the values around it, and a page reads those in the same pass as the line itself.
Cores and memory
Integrated laptop graphics beside sixteen threads is a machine nobody built. Each chip family comes with its own core counts and memory sizes.
The system version
A chip that arrived with a new system does not appear on an older one. The version narrows to those the chip actually shipped with.
The processor architecture
Client hints report the processor. Apple silicon named in this line with an architecture of x86 beside it is a contradiction in one pass.
The platform
A Mesa line on Windows is not a rare machine. It is a mismatch any check can see on the first reading.
Where our value comes from
This line is not kept in the profile. It is derived on every launch from the profile seed and given to the browser before the first page runs, so there is no stored list of values to drift apart.
The chip is drawn together with its maker, and the rest of the machine follows the chip. Cores, memory, system version and reported architecture are taken from what that chip really comes with.
A line chosen by hand goes through the same rule. A chip that contradicts the cores or the memory is named back to you rather than saved and quietly dropped.
How to check your own
The panel above shows the line your current browser reports. The self-test lives in the app and runs inside a profile against the engine that profile launched.
It prints the line the seed asked for next to the one that came back. The acceptance run for the build shipping today compared them the same way and they matched.
The name is one reading and the drawn frame is the other. On the shipping build both roads to that frame come back with the same bytes, so the two do not contradict each other.
What this does not do
- It does not turn one chip into another. The line answers together with the cores, the memory and the system version, and the whole set has to stay plausible.
- It does not change the frame the hardware draws. The name and the picture are separate readings, covered by different work, and a page may take the second one.
- It does not accept any hand picked combination. A chip that contradicts the rest of the machine is refused by name instead of being ignored in silence.
- It does not make a profile anonymous. Behaviour, address reputation and account history close more accounts than a chip name does.
Check it
Everything above comes from a file you can open.
- The line the self-test compares against the seed
- apps/desktop/src/lib/fpAudit.js
- Where the chip is drawn and what follows from it
- packages/shared/src/index.js
- The acceptance run of the build shipping today
- engine/приёмка-отчёт.json
- A build is not accepted until these hold
- engine/scripts/engine-invariants.js · engine/scripts/accept-engine.js
Questions
- Why is the line so long?
- Because it is a report and not a name. The graphics layer, the maker, the chip and the shader levels are all inside it, and that is what makes it the most specific value on the page.
- Does this line name my real chip?
- On our engine it comes from the profile seed, and the acceptance run compares what came back against that seed by name. The panel above shows what your current browser reports.
- Do two profiles report two chips?
- Yes. The chip is drawn per profile from the values that platform really reports, so two profiles on one computer describe two machines rather than one.
- Why does the same chip read differently on Linux?
- Because the line goes through Mesa there and carries an OpenGL level instead of a Direct3D one. The chip is the same and the report around it is not.
- Can I blank the line?
- You can, and a browser without it is rarer than any particular chip. The refusal then becomes the trait that identifies the machine, which is the opposite of what blanking was for.
See what your own profile answers
The self-test runs inside a profile and reports all 29 measurements by name, green and red alike.