IEEE 754 Converter

How to use

1. 1Pick a precision. binary64 is the JavaScript number, a C double, and the default for most languages. binary32 is the C float and the GPU shader float.
2. 2Type a decimal value into the top field: 0.1, 3.14, 1e10, 2.5E-3, Infinity, -Infinity, or NaN. The IEEE 754 bit pattern updates as you type, with the sign, exponent, and mantissa shown as a colored grid plus hex and binary readouts.
3. 3Read the classification chip and summary line to see whether the value is a normal number, a subnormal, a zero (plus/minus), an infinity, or a NaN, plus the unbiased exponent and the implicit leading bit.
4. 4To go the other way, paste a hex value (8 digits for binary32, 16 for binary64) or a binary string (32 or 64 bits) into the second field, with or without a 0x or 0b prefix. The decoded decimal appears with the same bit visualization.
5. 5Use the Send to bits and Send to decimal buttons to copy a value between the two fields, or click Copy next to any sign, exponent, mantissa, hex, or binary readout to grab just that piece.

About this tool

IEEE 754 Converter turns any decimal number into its IEEE 754 bit pattern, and any 32-bit or 64-bit hex or binary value back into the decimal it represents. Both single-precision (binary32, a C float) and double-precision (binary64, a C double and the JavaScript number) are supported. Conversion uses the platform's native Float32Array and Float64Array views over a shared ArrayBuffer, so the bit pattern you see is exactly the pattern your CPU, compiler, and runtime use; there is no hand-rolled rounding step that could disagree with the hardware. Every result is decomposed into the three IEEE 754 fields and rendered as a colored bit grid: the sign bit, the biased exponent (8 bits with bias 127 for binary32, 11 bits with bias 1023 for binary64), and the mantissa (23 bits or 52 bits). Numerical helpers print the raw exponent, the bias, and the unbiased exponent so you can see how the standard composes the value 1.mantissa multiplied by 2 to the unbiased exponent for normal numbers and 0.mantissa multiplied by 2 to (1 - bias) for subnormals. The classifier identifies the four cases the standard recognizes: zero (both positive and negative zero are distinct bit patterns), subnormal (also called denormalized; exponent is zero and the implicit leading bit drops to 0), normal (the common case), and the exponent-all-ones family (positive infinity, negative infinity, quiet NaN, signaling NaN). The decoded value re-emerges through the same Float32Array or Float64Array view, so the round trip is bit-exact: any pattern you paste in produces the exact float a CPU would load from that memory, and any decimal you type produces the bit pattern the CPU would store after a normal floating-point assignment. Useful when you are debugging 0.1 + 0.2 weirdness, reading a Wireshark dump, writing a binary protocol, comparing two compilers' rounding behavior, studying numerical analysis or computer architecture for a class, or just curious why JavaScript thinks 0.1 + 0.2 is 0.30000000000000004. Everything runs locally in your browser; the numbers you experiment with never leave your device.

Free to use. Works in your browser. No signup, no login.