İçeriğe geç

Bu sayfa henüz sizin dilinizde yok. İngilizce metni okuyorsunuz.

Fingerprint

A profile's graphics card: what a site sees and how to pick a pair

You pick the graphics card name for a profile yourself, and a site sees exactly that name. ARMANOS matches everything else a site reads about the card to the name: cores, memory and architecture follow the chosen card, while the state of capabilities comes from the machine the profile runs on.

ARMANOS ekibi6 minUpdated

In short

A site asks about the card twice. The name is read from the page, while the state of capabilities is held by the browser.

The pair moves together. The WebGL vendor and renderer change only as a pair.

Cores follow the card. Core count, memory and architecture come from the set of the chosen card.

A site asks about the card twice

The first question is simple: a page asks the browser for the graphics card name.

The second answer never reaches the page: the browser keeps that survey to itself. What gets out is the consequence, and loudest of all is WebGPU.

  1. 1

    The name you picked

    The vendor and the renderer: a site reads that pair straight off the page.

  2. 2

    The state the browser keeps

    One row for each capability, and the row holds a state rather than a name.

  3. 3

    What a site puts together

    A named card with no WebGPU behind it is worth a second look.

What WebGL and WebGPU are

WebGL is a page's road to the graphics card: through it a page draws an image and reads the vendor name and the renderer name.

WebGPU is a newer road to the same hardware. Platforms ask through it more and more, the large ones above all.

A profile answers on both roads: the name comes from the profile, and the capabilities come from the machine it runs on.

A profile on a rented server

Profiles often run on a rented server with no graphics card. The card name comes from the profile, and the state of capabilities from the machine itself.

The capability table is one for the browser and is drawn from what the machine sees.

On a server with no card, software rendering takes part of the work, and a processor handles it slower than a graphics card.

Pick the card name to suit the machine the profile lives on: a laptop card name on a server with no card gives a pair that never exists.

If you need live rendering and WebGPU, choose a machine with a real graphics card.

Why the name and the state must agree

A site reads the card name and the state of its capabilities and compares them. A laptop card name next to the state of a server with no card looks like two halves of different machines.

Each half is ordinary alone, together they disagree, and the disagreement shows in one request.

That is why ARMANOS matches everything else to the chosen name, while the name is best matched to the machine the profile lives on.

How to keep a profile on a server in order

For profiles on servers, choose card names that suit server hardware.

Run "Test fingerprint" after the first launch on a new server: the graphics card lines show whether the name and the state agree.

Profiles on desktops and laptops with a real graphics card get the state of capabilities from it, and the name agrees with the state by itself.

If you move a profile from a laptop to a server, check the pair again: the state of capabilities comes from the new computer.

The name is the easy half

The card name arrives at a site as a pair: the vendor and the renderer move together. Every platform has its own pool of such pairs.

Pick another pair in the WebGL field (Fingerprint > Change values) 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. 1

    The pair moves together

    A vendor without its matching renderer is a mismatch any check can see.

  2. 2

    The platform picks the pool

    A Windows renderer line looks nothing like the one a Linux machine produces.

  3. 3

    The processor follows the card

    Choosing another renderer redraws the architecture the profile reports.

How to choose a card

Open the profile and click Fingerprint > Change values.

Pick a pair in the "WebGL" field: the vendor and the renderer change together.

Check that the cores and memory updated and run "Test fingerprint".

How many cards a profile can carry

The list of cards belongs to the platform: a Windows desktop profile has seven of them, macOS ten.

The draw from that list falls to a profile by its number, so two of your profiles usually get different cards.

The name arrives as a pair: the vendor and the renderer travel together and do not change apart. A pair made of foreign halves would be more conspicuous than any single line.

Two cards on two profiles

Two of your profiles most often get different cards, even though they sit on one machine.

The choice from the list falls to a profile by its number and stays with it, so profiles never become copies of each other.

When to change the card

Change the card if the profile template or the platform changed. For a working account it is better to leave the card alone: an account's device should stay the same.

How not to get lost in card names

Pick a card from the list instead of typing a name by hand: the list holds only pairs that exist.

If you change the card of a profile that has already worked, do it once and leave it for long: frequent changes look odd by themselves.

Cores follow the card

The core count of an Apple chip is set by the chip itself: M1 has eight, M2 Max twelve, M3 Max fourteen or sixteen.

Such a chip never has another number, so the profile takes the number from the set assigned to that very card.

One shared set across all chips would hand an M2 ten cores, which does not exist.

So every class of card has its own set, and the harmonising runs when edits are saved.

What ARMANOS does about the graphics card

ARMANOS picks a pair for the profile from the list of cards for its platform and keeps the vendor and the renderer together.

The processor architecture, cores and memory adjust to the chosen card, so the combination stays one that real machines have.

The app keeps the chosen pair with the profile, and the next launch does not lose it.

How to check the pair in a minute

Open "Test fingerprint" in the profile menu: the lines on the graphics card, cores, memory and architecture show whether they agree.

The free check on the site reads the same values from a page in your browser and sends nothing out.

How to read the check lines

The graphics card line shows the name a site sees.

The cores and memory line shows they were taken from the set of that card.

The architecture line shows whether the processor agrees with the card.

The list of cards depends on the template platform: Windows and macOS each have their own.

Common questions

Can I choose a specific card?
Yes. Pick a pair in the "WebGL" field (Fingerprint > Change values): the processor architecture updates after it.
Does a server without a graphics card suit profiles?
It does. A site sees the card name from the profile and the state of the machine. For live rendering, pick a machine with a real graphics card.
Is the chosen pair saved?
Yes. The app keeps the chosen pair with the profile, and the next launch does not lose it.
Does the proxy change anything?
No. The address comes from outside, while every answer described here is born on your machine.

See what your browser answers

The free check reads 12 values, the graphics card included, and sends nothing out.