How does an IEEE 754 number encode a value?

A normal number is (-1)^sign × 1.mantissa × 2^(exponent − bias). The sign is one bit, the exponent is a fixed-width unsigned field offset by a bias, and the mantissa stores the fractional bits after an implicit leading 1. For binary64 (double) the bias is 1023, the exponent is 11 bits and the mantissa is 52 bits.

What is the exponent bias and why is it used?

The exponent is stored as an unsigned integer, but real exponents can be negative. The bias is subtracted to recover the true exponent: 127 for single precision, 1023 for double. Storing biased exponents lets the bit pattern be compared as an ordinary integer, which makes sorting and comparison hardware simpler.

How are Infinity and NaN represented?

Both use an all-ones exponent field. If the mantissa is all zeros the value is positive or negative Infinity depending on the sign bit. If the mantissa is non-zero the value is NaN (Not a Number). A leading mantissa bit distinguishes quiet NaN from signalling NaN.

Why does 0.1 not have an exact representation?

0.1 in decimal is a repeating fraction in binary, just like 1/3 repeats in decimal. No finite binary mantissa can store it exactly, so IEEE 754 rounds to the nearest representable value. The decoder shows the true stored bits, which is why the displayed stored value can differ slightly from what you typed.

Is this floating-point reference private?

Yes. The bit decoder uses the browser's own DataView to read bytes locally, and the format table is static. There are no network calls and nothing you type is uploaded.

IEEE 754 Floating-Point Reference

The IEEE 754 Floating-Point Reference combines a static format table with a live bit decoder. Type any number and it shows the exact single- and double-precision bit patterns the way your CPU actually stores them — so you can see why 0.1 is not really 0.1 and where the sign, exponent and mantissa bits land in binary32 and binary64.

How it works

IEEE 754 binary formats all share the same structure: one sign bit, a fixed-width exponent field stored with a bias, and a mantissa (also called the significand or fraction). For a normal number the value is:

value = (-1)^sign × 1.mantissa × 2^(exponent − bias)

The leading 1. is implicit (the “hidden bit”) in every format except the x87 80-bit extended, which stores it explicitly. The bias makes the stored exponent unsigned: it is 2^(expBits-1) − 1, giving 127 for single precision and 1023 for double. Two exponent patterns are special:

exponent = 0       → ±0 (mantissa 0) or subnormal numbers (mantissa ≠ 0)
exponent = all 1s  → ±Infinity (mantissa 0) or NaN (mantissa ≠ 0)

The decoder writes your number into an ArrayBuffer with DataView.setFloat32 / setFloat64, then reads back the raw integer bytes — so the bits shown are the genuine stored representation, including rounding, not an approximation.

Example and notes

Decode 0.1 and the single-precision mantissa shows a repeating ...11001100 pattern: 0.1 cannot be stored exactly in binary, so it rounds to the nearest representable value, which is why 0.1 + 0.2 !== 0.3 in most languages. Compare formats in the table: half precision (binary16) holds only about 3.3 decimal digits and tops out near 65504, single precision (binary32, C float) holds about 7.2 digits, and double precision (binary64, JavaScript Number) holds about 15.9 digits with a range past 10^308. The wider the exponent field, the larger the range; the wider the mantissa, the more precision.

IEEE 754 Floating-Point Reference

Email me this result

How it works

Example and notes