BYTETOOLS

IEEE 754 Floating Point Converter

Convert decimals to IEEE 754 single or double precision and back. See sign, exponent and mantissa bits, the exact stored value and the rounding error.

Normal
Classification
+ (0)
Sign
123
Exponent (stored)
-4
Exponent (unbiased)

Bit layout

00111101110011001100110011001101

sign · exponent · mantissa (fraction)

Hex representation

0x3DCCCCCD

Exact stored value

0.100000001490116119384765625

Rounding error vs. your input: -1.490116e-9

What is the IEEE 754 Floating Point Converter?

The ByteTools IEEE 754 Converter shows exactly how a decimal number is stored as a 32-bit float or 64-bit double.

  • Single (32-bit) and double (64-bit) precision, both directions
  • Colour-coded sign / exponent / mantissa bit breakdown
  • Exact stored decimal value — not an approximation
  • Rounding error reported for single precision
  • Classifies normals, subnormals, zero, Infinity and NaN
  • 100% client-side and instant

How to use the IEEE 754 Floating Point Converter

  1. 1

    Choose the direction: decimal → bits, or a hex/binary pattern → decimal.

  2. 2

    Pick single (32-bit) or double (64-bit) precision.

  3. 3

    Enter the value or pattern — Infinity and NaN are accepted too.

  4. 4

    Read the colour-coded sign, exponent and mantissa fields and the hex form.

  5. 5

    Check the exact stored value and the rounding error against your input.

About the IEEE 754 Floating Point Converter

The ByteTools IEEE 754 Converter shows exactly how a decimal number is stored as a 32-bit float or 64-bit double. Enter a value like 0.1 and see its bit pattern split into colour-coded sign, exponent and mantissa fields, the hex form (0x3DCCCCCD as a float), and — uniquely — the exact decimal value actually stored, digit for digit.

It works in reverse too: paste a hex or binary bit pattern and get the number it encodes, with the stored exponent, unbiased exponent and classification (normal, subnormal, zero, infinity or NaN). For single precision the tool also reports the rounding error between your input and what fits in 24 bits of significand.

This is the fastest way to understand why 0.1 + 0.2 ≠ 0.3. All conversion happens 100% locally in your browser — nothing is uploaded or stored.

Frequently asked questions

Why is 0.1 not stored exactly in floating point?

Binary floating point can only represent fractions whose denominators are powers of two. 0.1 is 1/10, which has a factor of 5, so it becomes an infinite repeating binary fraction that must be cut off. A 32-bit float actually stores 0.100000001490116119384765625 — this tool shows you that exact value.

What are the sign, exponent and mantissa fields?

A float is packed as one sign bit, an exponent field (8 bits for single, 11 for double) and a mantissa or fraction field (23 or 52 bits). The value is roughly ±1.mantissa × 2^(exponent−bias), with a bias of 127 or 1023. The tool colour-codes each field so you can read the pattern directly.

Why does 0.1 + 0.2 not equal 0.3?

None of 0.1, 0.2 or 0.3 is exactly representable in binary, and each is rounded independently. The stored 0.1 and 0.2 add to a value that is one unit-in-the-last-place away from the stored 0.3, giving the famous 0.30000000000000004. Convert each of the three numbers here to see the differing stored values.

What is a subnormal (denormal) number?

When the exponent field is all zeros, the format drops the implicit leading 1 and represents numbers even smaller than the smallest normal value, trading precision for range near zero. The converter labels these as subnormal and decodes them with the correct fixed exponent.

How accurate is single vs double precision?

Single precision carries 24 significant binary digits — about 7 decimal digits — while double carries 53, about 15 to 16 decimal digits. That is why JavaScript, Python and most scientific code default to doubles, and why graphics and ML code that tolerates less precision uses floats to halve memory.

Is any of this computed on a server?

No. The bit-level conversion uses your browser's own IEEE 754 hardware representation via typed arrays, and the exact decimal expansion is computed locally with big-integer math. Nothing is transmitted or stored.

Related tools