The check on the accuracy page that reports how many bits this device's numbers carry, how many processor threads and how much memory the browser shows, and what it says about the graphics processor.
How the precision is kept
The count for the processor is found by exact halving, with no rounded factor. The digit estimate for a graphics processor below 32-bit multiplies the reported bit count by log10(2) and rounds down. The graphics rows are a capability report from the browser (shader precision format, renderer name, WebGPU adapter), not a measurement of the card. Nothing is sent anywhere; the result is only shown.
Calculations under this policy
2 calculations in 1 source file. The code is read from the released app when this page loads. It is the calculation people run, not a copy kept for this page.
accuracy.jsShared shell, every app64-bit2 calculationsReviewed
TestsNone found by the review
Significand width of a number
Exact
How many bits of a number this device keeps.
bits = the first n where 1 + 2⁻ⁿ = 1
Halving a power of two is exact, and the comparison 1 + x ≠ 1 is the test itself, so the count is exact. With round-to-nearest-even arithmetic the loop ends at 53 for a 64-bit number. The loop is capped at 200 halvings.
accuracy.js
lines 59 to 60
/** Bits in the significand of a Number here. Every JavaScript engine gives 53; this reads it rather than assuming. */
const significandBits = () => { let bits = 0, x = 1; while (1 + x !== 1 && bits < 200) { x /= 2; bits++; } return bits; };
Digits of a graphics float
64-bit
The number of significant digits stated for the graphics processor's float type.
bits < 23: digits = max(1, ⌊(bits + 1) × log₁₀ 2⌋); bits ≥ 23: the fixed text "about 7"
The bit count comes from the browser's WebGL report and is an integer. Below 23 bits the digit count is that integer plus one, times Math.log10(2), rounded down. From 23 bits up the text says about 7 digits whatever value was reported.
accuracy.js
lines 110 to 115
} else if (gl.bits >= 23) {
gpuText = '32-bit shader math' + (gl.name ? ': ' + gl.name : '');
gpuNote = `${gl.bits + 1}-bit significand: about 7 significant digits. This is what WebGL reports for every graphics card, whatever it can do natively: browsers do not expose 64-bit shader math.`;
warn = 'Work the apps hand to the graphics processor is calculated in 32-bit numbers and can provide less mathematical precision than the 64-bit numbers the apps calculate with on the processor. The lists on this page mark the calculations where a 32-bit step reaches a number you read or save.';
} else {
gpuText = 'Under 32-bit shader math' + (gl.name ? ': ' + gl.name : '');
In detail
Method
Halve x from 1 until 1 + x equals 1; the number of halvings is the significand width. For the graphics processor, read the WebGL shader precision format for a high-precision float in a fragment shader (medium when high is not offered), the renderer name when the browser exposes it, and the WebGPU adapter and its shader-f16 feature.
Number types
64-bit numbers and small integers.
Limits
The loop stops at 200 halvings. A graphics float of 23 bits or more is always described as about 7 digits; that text is fixed, not computed. WebGL and WebGPU do not offer 64-bit shader math, so a device with WebGL always reads 32-bit; with several graphics cards the browser reports one adapter. Processor threads come from navigator.hardwareConcurrency and memory from navigator.deviceMemory, which only Chromium offers, rounded down to a power of two and capped at 8 GB; nothing here is sent anywhere.
Approach: 64-bit, direct
Every value is a 64-bit number from input to result. Formulas are closed form or a direct solve, and every comparison uses a stated tolerance.