IEEE 754 Float Explorer
Decompose numbers into IEEE 754 binary32/64 sign, exponent, and mantissa bits. Toggle bits, step floats, and see exact decimal values with rounding error analysis.
Loading tool...
What is IEEE 754 Float Explorer?
The IEEE 754 Float Explorer is a browser-based tool for inspecting how floating-point numbers are actually stored. It decomposes any value into its binary64 or binary32 bit pattern — sign bit, biased exponent, mantissa, and implicit leading bit — then reconstructs the exact rational value the bits represent using BigInt arithmetic, entirely offline.
Key Benefits
- Understand why decimal fractions like 0.1 are stored inexactly
- Debug float comparisons and equality surprises at the bit level
- Measure ULP spacing and precision at any exponent
- Decode hex bit patterns from debuggers, specs, or wire formats
- Teach or learn IEEE 754 with a live, clickable bit grid
Common Use Cases
- •Explaining the classic 0.1 + 0.2 result in code reviews or class
- •Verifying float32 rounding behavior before porting code to GPU or embedded targets
- •Decoding bit patterns seen in hex dumps, serializers, or protocol buffers
- •Checking subnormal handling near zero for scientific or DSP computations
- •Preparing interview material on floating-point internals
How to Use the IEEE 754 Float Explorer
- Enter a number: Type a decimal number such as 0.1 or -2.75, or paste a full hex bit pattern like 0x3FB999999999999A. Pick binary64 or binary32 precision.
- Read the bit fields: The color-coded grid shows the sign bit, biased exponent, and mantissa, plus the classification: normal, subnormal, zero, infinity, or NaN.
- Toggle and step bits: Click any bit to flip it and watch the value update, or use the next/previous buttons to step through representable floats and measure ULP spacing.
- Check exactness: Compare the exact BigInt-computed decimal value and the rounding error analysis against the number you typed.
Key Features
- Decompose numbers into sign, exponent, and mantissa bit fields for binary64 and binary32.
- Interactive bit grid — click any of the 64 or 32 bits to toggle it and rebuild the value.
- Classifies values as normal, subnormal, zero, infinity, or NaN with color cues.
- Exact decimal reconstruction of the stored bit pattern using BigInt arithmetic.
- Step to adjacent representable floats to visualize ULP spacing at any scale.
- Rounding error panel comparing the requested decimal with the value actually stored.
Frequently Asked Questions
What is the difference between binary32 and binary64?
binary32 (float) uses 32 bits — 1 sign, 8 exponent, 23 mantissa — giving roughly 7 decimal digits of precision. binary64 (double) uses 64 bits — 1 sign, 11 exponent, 52 mantissa — giving roughly 15–17 digits. JavaScript numbers are binary64, while many GPUs, shaders, and embedded systems use binary32.
Why does 0.1 + 0.2 not equal 0.3?
Neither 0.1 nor 0.2 is a sum of powers of two, so each is rounded to the nearest representable float. The sum of those rounded values differs from the rounded value of 0.3. This explorer shows the exact stored value of 0.1: 0.1000000000000000055511151231257827021181583404541015625.
What are subnormal numbers?
When the exponent field is all zeros and the mantissa is non-zero, the value is subnormal (denormal). There is no implicit leading 1 bit, so very small numbers near zero are represented with reduced precision instead of underflowing straight to zero.
Can I enter a raw hex bit pattern from a debugger?
Yes. Enter a 16-hex-digit value like 0x3FB999999999999A for binary64 or an 8-hex-digit value like 0x3DCCCCCD for binary32, and the explorer decodes it instantly.