Why 32 bits specifically?

IEEE 754 single precision ("float32") always uses exactly 32 bits: 1 sign bit, 8 exponent bits, and 23 mantissa (fraction) bits. This tool targets that format specifically rather than the 64-bit double-precision format.

What do the sign, exponent, and mantissa sections mean?

The sign bit is 0 for positive and 1 for negative. The 8-bit exponent is stored with a bias of 127 (so a stored value of 01111111 = 127 means an actual exponent of 0). The 23-bit mantissa holds the fractional part of the normalized value 1.mantissa × 2^exponent.

Can this represent every decimal number exactly?

No — single precision has limited exponent range and only 23 mantissa bits, so many decimals (like 0.1) can only be approximated, not represented exactly. The tool shows exactly what the browser's native float32 rounding produces.

What happens with special values like Infinity or NaN?

They're supported — Infinity encodes as an exponent of all 1s with a zero mantissa, and NaN as an exponent of all 1s with a nonzero mantissa, matching the IEEE 754 standard's special-value encoding.

Floating Point to Binary Converter - IEEE 754 Single-Precision

Overview

Introduction

Floating-point numbers aren't stored as a simple binary version of their decimal digits — they follow a precise IEEE 754 layout of sign, exponent, and mantissa bits.

This tool shows exactly what that layout looks like for any decimal number, using the browser's own native float32 encoding rather than a hand-rolled approximation.

What Is Floating Point to Binary Converter?

A converter that encodes a decimal number as IEEE 754 single-precision (32-bit) binary and displays the full bit string plus its sign/exponent/mantissa breakdown.

It relies on the JavaScript engine's built-in `DataView.setFloat32`, so the result matches exactly what real single-precision hardware and software would produce.

How Floating Point to Binary Converter Works

The input is parsed as a number, written into a 4-byte `ArrayBuffer` with `DataView.prototype.setFloat32(0, value)` (using the platform's native IEEE 754 rounding), then read back byte-by-byte with `getUint8`.

Each of the 4 raw bytes is formatted as 8-bit binary and concatenated into a 32-character string, which is then split into its 1-bit sign, 8-bit exponent, and 23-bit mantissa sections for display.

When To Use Floating Point to Binary Converter

Use it when learning or teaching how floating-point numbers are actually stored in memory, bit by bit.

It's also useful for debugging low-level code, binary file formats, or network protocols that embed raw IEEE 754 float32 values.

Often used alongside Binary to Floating Point Converter.

Features

Advantages

Uses the browser's real IEEE 754 implementation, so results exactly match what any float32-compliant system would produce.
Breaks the 32 bits down into sign/exponent/mantissa for easier learning, not just a flat bit string.
Handles negative numbers, zero, and special values (Infinity, NaN) correctly.

Limitations

Only supports 32-bit single precision, not 64-bit double precision — the browser's native double-precision numbers are rounded to float32 before encoding.
Many decimal fractions (e.g. 0.1) cannot be represented exactly in binary floating point, so the encoded value may differ very slightly from the typed decimal.

Examples

A simple positive integer

Input

Output

00111111100000000000000000000000

1.0 encodes as sign 0, exponent 01111111 (127, the bias for exponent 0), and an all-zero mantissa (since 1.0 = 1.0 × 2^0).

A negative power of two

Input

-2

Output

11000000000000000000000000000000

-2.0 encodes as sign 1 (negative), exponent 10000000 (128, meaning an actual exponent of 1), and an all-zero mantissa (since 2.0 = 1.0 × 2^1).

Best Practices & Notes

Best Practices

Feed the result into the Binary to Floating Point Converter to confirm the round trip returns the original (or a very close) value.
Compare simple powers of two (1, 2, 4, 0.5) to build intuition for how the exponent field shifts predictably.

Developer Notes

Encoding is delegated entirely to the runtime's `DataView.setFloat32`/`getUint8` rather than a hand-written bit-manipulation algorithm, guaranteeing exact IEEE 754 rounding and special-value behavior without reimplementing the standard.

Floating Point to Binary Converter Use Cases

Learning or teaching the IEEE 754 single-precision bit layout
Debugging binary file formats or network protocols that embed float32 values
Verifying a hand-computed floating-point encoding exercise

Common Mistakes

Expecting an exact bit-for-bit match with a hand-computed encoding of a non-exactly-representable decimal like 0.1 — small rounding differences are normal, not a bug.
Confusing this with double-precision (64-bit) encoding, which uses a different bit layout (11 exponent bits, 52 mantissa bits).

Tips

Try 0 and -0 to see how IEEE 754 distinguishes positive and negative zero via the sign bit alone.
Try a very large number to see the exponent field grow while the mantissa still holds only the fractional precision.

Floating Point to Binary Converter