a mediump claim of fp32 precision is delivered by the arithmetic
Check id shader-mediump-claim-vs-arithmetic
What an ordinary browser yields
A mediump format reporting fp32-class precision computes ((u+1/8192)-u)*8192 as 1.0 (red 255) — the arithmetic delivers the precision the format claims.
What a detector infers
getShaderPrecisionFormat is a claim about float precision; a shader that computes a value only fp32 can represent is the GPU keeping or breaking that claim. The probe evaluates ((u + 1/8192) - u) * 8192 at mediump precision with u set to 1.0: in true fp32 this is 1.0 and the red channel reads 255, while in fp16 the tiny addend is lost and the result collapses toward zero. So a context that advertises fp32-class mediump — a reported precision of at least 23 bits — but computes at lower precision is contradicting its own precision report, the shape a software rasteriser like SwiftShader or llvmpipe shows under docker when its format is spoofed to resemble a real GPU. The check is gated on the claim itself: real mobile GPUs such as Adreno and Mali honestly report fp16-class mediump and genuinely compute in fp16, so claim matches delivery, the check never runs on them, and it cannot false-positive on mobile. It only speaks when a browser has promised fp32 precision, and then it holds the arithmetic to that promise.
How to resolve it
getShaderPrecisionFormat and the shader compiler read the same GPU, so an fp32 claim must be honoured by fp32 arithmetic. A software rasteriser reporting a spoofed high-precision format while computing at another precision is the contradiction. Present the precision the hardware actually delivers.
Read in the wild by
CloakBrowser issues
The tracker records a spoofed shader-precision format read back inconsistently with the arithmetic the GPU actually performs.
CloakHQ/CloakBrowser #84 (shader precision leak)
CloakHQ/CloakBrowser#84Every attribution traces to a published artifact. See the sources and their limits.
Nearby checks in Render & GPU
- WebGPU's build constants are identical in every realm
webgpu-sync-surface-vs-realmWebGPU's cheapest fingerprint is not the GPU at all. navigator.gpu.getPreferredCanvasFormat() and navigator.gpu.wgslLanguageFeatures are… - the GL limits the driver reports are limits the driver will actually honour
webgl-limits-vs-driverEvery other WebGL check on this page reads what getParameter SAYS. - ANGLE's translated shader is written in the dialect the renderer string implies
shader-backend-vs-rendererThe UNMASKED_RENDERER_WEBGL string is a label — a piece of text a page can rewrite to name any GPU and any graphics backend. - every extension WebGL advertises can actually be instantiated
webgl-extensions-vs-drivergetSupportedExtensions() returns a list a page can rewrite; getExtension(name) either hands back a real extension object or null, and that… - the clear path and the shader path paint opaque red to the same bytes
webgl-draw-path-invarianceOpaque red can be produced two ways: the fixed-function clear path, and a fragment shader emitting vec4(1,0,0,1). - silence renders as exact zero through the Web Audio graph
audio-render-silence-integrityThe other audio checks compare two renders of a sound; this one renders silence and asserts it stayed silent, which catches a different kind… - a constant signal renders at exactly the amplitude it was given
audio-render-dc-integrityThe companion to the silence check below, and the input that one structurally cannot see. - a browser that implements EME can satisfy its mandatory ClearKey baseline
eme-clearkey-baselineEncrypted Media Extensions is the DRM entry point, and it has one part that cannot be missing.
Clearcote is a browser built for fingerprint coherence
It is a Chromium fork, maintained by the same people who wrote this reference. It ships as a compiled browser rather than as a stealth script injected into someone else's — which is a description of how it is built, and is not an argument about how it behaves on this check.
This audit takes no position on how Clearcote scores on Render & GPU checks, on this one, or anywhere else. It has no baseline corpus of other people's fingerprints to rank you against and no vendor scoreboard — nearly every check is self-referential, asking one browser the same question through two independent APIs and reporting whether both answers can be true at once. It runs identically on any browser, including ours. Run it on yours and read the result yourself.
See the other checks in Render & GPU — the family shader-mediump-claim-vs-arithmetic belongs to.