Această pagină nu este încă în limba dumneavoastră. Citiți textul în engleză.
Blog
What a real machine reports about its GPU
Echipa ARMANOS6 min
Two answers about one card
A page can ask the browser for the name of the graphics card.
The second answer is the browser's own survey of what the card can do. That table is not handed to pages.
- 1
Asks for the name
The vendor and the renderer the browser reports for the card.
- 2
The state the browser keeps
One row for each capability, and the row holds a state rather than a name.
- 3
What a site can put together
A named card with no WebGPU behind it is worth a second look.
What the rented machine answered
We put both questions to a rented Windows server running our own build. It has no graphics card of its own, which is exactly what makes its answer worth reading.
Every row of the capability table came back switched off. Some of them fall back to software rendering, the rest are off with nothing behind them at all.
| Measured on the rented machine | Answer |
|---|---|
| Capability rows the engine reported | 14 |
| Rows served by a graphics card | 0 |
| Rows falling back to software | 5 |
| Cards the machine listed | 2, the same basic driver twice |
| Driver entries the machine listed | 0 |
Where the road is missing
WebGPU is a second road to the same hardware, and on that machine it was not narrow but absent. There was no entry point to ask in the first place.
We tried three ways of starting the browser, each of them twice: hidden and with a real window on screen. All 6 attempts answered the same way.
Started as it ships
No entry point at all.
Asked for a software adapter
No entry point, and the request had nothing to attach itself to.
Asked for software rendering throughout
No entry point, on the hidden run and on the visible one alike.
Why a launch flag could not help
A launch flag chooses which adapter serves WebGPU. It cannot help once the browser has already marked the whole capability off in its survey of the machine.
That mark goes down before any adapter is chosen. No combination of flags moved it, and the reason sits a layer underneath the thing they control.
The name is the easy half
The card name a profile reports is drawn from its seed as a pair. The vendor and the renderer move together, and every platform has its own pool of pairs.
Pick another renderer from the list and the processor architecture the profile reports is redrawn along with it. A card from one family beside a processor from another describes a machine nobody sells.
- 1
The pair moves together
A vendor without its matching renderer is a mismatch any check can see.
- 2
The platform picks the pool
A Windows renderer line looks nothing like the one a Linux machine produces.
- 3
The processor follows the card
Choosing another renderer redraws the architecture the profile reports.
An unmeasured road is not a pass
The acceptance run on that machine could not take a WebGPU snapshot, because there was nothing to take one from. It counts that line as failed rather than skipped, and the build was not accepted.
So what we say about WebGPU on Windows stops where the measurement stopped. A road nobody has driven is not a road we call open.
What this does not claim
- It does not claim that WebGPU works on a Windows machine that has a card. That road has not been measured on one yet, and until it is we say nothing about it either way.
- The measurement is one rented server without a graphics card. A desktop with a card answers differently, and what carries over is the shape of the answer rather than the numbers.
- It does not claim that a card name agreeing with its state makes a profile safe. It removes one contradiction out of many, and behaviour, payment details and the history of the account remain untouched by any browser.
- The capability table belongs to the machine it runs on. A profile does not carry one, and our engine does not rewrite it.
Where you can see this yourself
Every number above comes out of a file you can open and read.
- The capability table the machine reported
- docs/замеры/gpu-status-windows-04-09.log
- 6 attempts at WebGPU on the same machine
- docs/замеры/webgpu-windows-04-09.log
- The pool of card pairs and what a pick must match
- packages/shared/src/index.js
- An unmeasured WebGPU line counts as a failure
- engine/scripts/engine-invariants.js
- A pair picked by hand is kept with the profile
- apps/desktop/src/main/main.js
Questions
- Why not make the table agree with the card name?
- It is the machine's own answer about its drivers, not a value a profile carries. Rewriting it would change how the browser draws for every profile on that computer.
- Does this make a server a bad place to run profiles?
- It means a server answers graphics questions the way a server does. A site meeting a named card with no WebGPU behind it sees a machine without a card, which is what it is.
- Would a software renderer have filled the table?
- It would have moved some rows and not the verdict. The capability was already marked off before any adapter came into the question at all.
- Is the card name kept anywhere on disk?
- Not while it is generated: the pair comes from the profile seed at every launch. A pair you pick from the list is kept with the profile, so the next launch still has it.
- Does a proxy change any of this?
- No. The address arrives from elsewhere, and every answer described here is produced by the machine in front of you.
Next to this
WebGPU fingerprint
The second road to the same hardware and what it hands over.
WebGL renderer
The line that names the card and how far it can be moved.
The engine we build
What is changed inside the browser and what is measured on it.
Free fingerprint check
12 values read in your browser, with nothing sent anywhere.
See what your own browser answers
The check reads 12 values and sends nothing anywhere.