What is the difference between single and double precision?

Single precision (32-bit) uses 1 sign bit, 8 exponent bits and 23 mantissa bits. Double precision (64-bit) uses 1 sign bit, 11 exponent bits and 52 mantissa bits, giving far more range and roughly 15-17 significant decimal digits versus 6-9 for single.

Why does my number not convert exactly?

Many decimal fractions like 0.1 cannot be represented exactly in binary floating point. The converter shows the exact bit pattern that is actually stored, which is the nearest representable value rounded to the available mantissa bits.

What is the exponent bias?

The exponent is stored with a bias so it can represent negative powers without a sign. Single precision adds a bias of 127 and double precision adds 1023. The tool shows both the raw exponent bits and the unbiased value.

How is the sign bit interpreted?

The leftmost bit is the sign: 0 means positive and 1 means negative. The rest of the bit pattern stays the same regardless of sign, so flipping just that bit negates the number.

How does the converter compute the bits?

It writes your number into a typed array (Float32Array via setFloat32 for single, or setFloat64 for double) in big-endian order, then reads the raw bytes back out as an unsigned integer to produce the hex and binary.

What hex output does 3.14159 give?

In 32-bit single precision, 3.14159 stores as 0x40490FD0, with sign 0, biased exponent 10000000 (unbiased 1) and a 23-bit mantissa. This is the nearest representable float to pi-ish.

Is anything uploaded?

No — the conversion uses your browser's own typed-array support and nothing is sent to a server.

IEEE 754 Floating-Point Converter

IEEE 754 floating-point converter

Convert any decimal number into its IEEE 754 representation in 32-bit single or 64-bit double precision. IEEE 754 is the floating-point standard used by virtually every programming language and CPU, so this tool is handy for developers debugging precision bugs, students learning binary representation, and anyone curious why 0.1 + 0.2 is not exactly 0.3.

How it works

A floating-point number is split into three fields. The converter writes your value into a typed array (setFloat32 for single, setFloat64 for double) in big-endian order, then reads the raw bytes back as an unsigned integer to derive the hexadecimal and binary patterns. It then splits the binary into:

Sign bit — 1 bit; 0 is positive, 1 is negative.
Exponent — the stored (biased) exponent; subtract the bias (127 single / 1023 double) to get the real power of two.
Mantissa — the fraction bits (23 single / 52 double).

Field	Single (32-bit)	Double (64-bit)
Sign	1 bit	1 bit
Exponent	8 bits (bias 127)	11 bits (bias 1023)
Mantissa	23 bits	52 bits

Example

Entering 3.14159 in single precision yields hex 0x40490FD0, binary 01000000 01001001 00001111 11010000: sign 0 (positive), exponent 10000000 (unbiased 1), and a 23-bit mantissa. Because many decimals cannot be stored exactly in binary, the bits represent the nearest representable value.

Everything is computed locally in your browser — nothing is uploaded.