IEEE 754 Floating-Point Converter

What Is IEEE 754 Floating Point?

// Float ↔ hex through the raw IEEE 754 bits (works in any browser / Node.js)
const buf = new DataView(new ArrayBuffer(8));

function floatToHex32(value) {
  buf.setFloat32(0, value); // rounds to nearest even
  return '0x' + buf.getUint32(0).toString(16).toUpperCase().padStart(8, '0');
}

function hexToFloat32(hex) {
  buf.setUint32(0, parseInt(hex, 16));
  return buf.getFloat32(0);
}

floatToHex32(0.1);        // '0x3DCCCCCD'
floatToHex32(3.14159);    // '0x40490FD0'
hexToFloat32('3DCCCCCD'); // 0.10000000149011612

Key Features

IEEE 754 Conversion Examples

0.1

0x3DCCCCCD — actually stored as 0.100000001490116119384765625

3.14159

0x40490FD0

65504

0x7BFF — the largest finite FP16 value

-0

0x80000000 (FP32), while +0 is 0x00000000

How to Convert IEEE 754 Floating-Point Numbers

1. 1

   Choose a floating-point format

   Single (FP32) is preselected. Switch to Double (FP64) for JavaScript/Python-style numbers, or Half (FP16) and bfloat16 for the 16-bit formats used in machine learning and graphics.

2. 2

   Type a decimal number

   Enter any value — 0.1, -2.5e3, 65504 — or use the special-value chips for ±0, ±Infinity, NaN, the smallest subnormal, and the largest finite value. Conversion happens as you type.

3. 3

   Read the color-coded bit layout

   The sign bit, exponent field, and mantissa are highlighted in different colors — the complete float to binary conversion at a glance — with the field breakdown table showing the raw bits, the bias arithmetic, and the implicit leading bit.

4. 4

   Check the exact stored value and error

   The accuracy panel prints the value actually stored — every digit, computed exactly — alongside the rounding error against what you typed, plus the previous and next representable neighbors and the ULP gap.

5. 5

   Flip bits, paste hex, copy results

   Click any bit to flip it, or paste hex (3DCCCCCD) and binary strings to decode them back to decimal. Copy the hex, the binary, the exact value, or a shareable link that reproduces the exact bit pattern.

Common Floating-Point Mistakes

print(0.1)  # 0.1 — looks exact, is not

0.1 stored (FP64) = 0.1000000000000000055511151231257827021181583404541015625

if (0.1 + 0.2 === 0.3) { … }   // never runs

if (Math.abs(a - b) < 1e-9) { … }   // tolerance sized to your data

fp16(65520)   → Infinity (0x7C00) — silent overflow

bf16(65520)   → finite (bfloat16 keeps 8 exponent bits)

if (x === NaN) { … }        // always false, even when x IS NaN

if (Number.isNaN(x)) { … }  // the correct test

What You Can Do with the IEEE 754 Converter

Debug serialized binary data

Paste the hex you found in a network capture, GPU buffer, register dump, or file format and decode it to the exact decimal value — or go the other way to write test fixtures. Byte-order note: the hex shown is the big-endian bit pattern — if your dump is little-endian, reverse the byte order before pasting.

Understand ML quantization

Check whether your values survive FP16's 65504 ceiling, compare FP16 against bfloat16 precision loss digit by digit, and inspect the subnormal range where gradients underflow.

Explain a floating-point bug

When a colleague asks why two 'equal' numbers differ, send a permalink showing both bit patterns and the exact stored values — the argument settles itself. Pair it with the text diff tool for longer dumps.

Learn or teach the encoding

Computer-architecture coursework becomes concrete when students can click the exponent bits and watch the bias arithmetic update. The field breakdown table mirrors how textbooks draw the format.

Decode embedded and industrial registers

Modbus, CAN, and sensor payloads routinely carry FP32 values as raw hex words. Paste the word here to convert the IEEE 754 hex to decimal and read the physical value without writing a scratch script.

IEEE 754 Formats & Special Values

The four binary formats at a glance

binary16 (FP16): 1 sign + 5 exponent + 10 mantissa bits, bias 15, max 65504, ~3.3 decimal digits. bfloat16: 1 + 8 + 7, bias 127, max ≈ 3.39 × 10³⁸, ~2.3 digits. binary32 (FP32): 1 + 8 + 23, bias 127, max ≈ 3.40 × 10³⁸, ~7.2 digits. binary64 (FP64): 1 + 11 + 52, bias 1023, max ≈ 1.80 × 10³⁰⁸, ~15.9 digits. The pattern: exponent bits buy range, mantissa bits buy precision, and bfloat16 deliberately trades all its precision for FP32's range.

How a value is assembled

A normal number decodes as (−1)^sign × 1.mantissa × 2^(exponent − bias). The leading 1 is implicit — it is not stored, which is why a 23-bit mantissa field delivers 24 bits of precision. The stored exponent is the true exponent plus the bias (127 in FP32), so 2⁰ is stored as 01111111. The field breakdown table in this tool shows each step of that arithmetic for the current value.

Special values: the reserved exponent patterns

Exponent all ones with mantissa zero is ±Infinity; with any non-zero mantissa it is NaN (the canonical quiet NaN sets the mantissa's top bit). Exponent all zeros with mantissa zero is ±0; with a non-zero mantissa it is a subnormal, decoded as 0.mantissa × 2^(1 − bias) — no implicit leading 1. These rules are identical across all four formats, which is why the same chips work in each.

Rounding: nearest, ties to even

When a value falls between two representable numbers, IEEE 754's default mode rounds to the nearer one; on an exact tie it picks the one whose last mantissa bit is 0 (ties to even), which prevents systematic drift. This converter applies exactly that rule when narrowing your decimal input into the target format, and the error panel shows the resulting signed difference exactly.

ULP: the grid spacing of floats

Representable floats are not evenly spread — the gap between neighbors (one unit in the last place) doubles at each power of two. Near 1.0 a double's ULP is 2⁻⁵² ≈ 2.22 × 10⁻¹⁶; near 2⁵³ the ULP reaches 1.0 and integers start to skip. The neighbors panel prints the current ULP exactly, which is the honest answer to 'how precise is my number here?'.

Floating-Point Best Practices

Never compare floats with ==

After any arithmetic, two mathematically equal expressions can sit one ULP apart. Compare against a tolerance appropriate to your magnitudes — or count ULPs between the bit patterns, which this tool lets you inspect directly.

Keep money out of binary floats

No power-of-two grid contains 0.10 exactly, so currency in floats accumulates visible errors. Use integer cents or a decimal type; the exact stored-value panel here is the standing proof of why.

Pick the 16-bit format by range, not habit

If your values can exceed 65504 — losses, gradients, physics spikes — FP16 will overflow to Infinity where bfloat16 sails on. If everything is normalized into a narrow band, FP16's extra mantissa bits give visibly better precision.

Mind the double-rounding trap when narrowing

Converting decimal → double → half can land one ULP away from converting decimal → half directly in rare halfway cases. This tool rounds your decimal input to the target format in a single step, so what you see is the honest IEEE 754 answer.

Expect integers to break above 2⁵³

A double stores every integer up to 2⁵³ exactly, then starts skipping — 2⁵³ + 1 is unrepresentable. If you handle IDs or counters near that scale, use 64-bit integers or strings, and check suspicious values here at the bit level.

IEEE 754 Converter FAQ