FP16 & bfloat16 Bit Pattern Visualizer

Visualize the bit patterns of half-precision floating point (FP16, IEEE 754 binary16) and bfloat16. Convert decimal to bits and back, with color-coded sign, exponent, and mantissa fields. Useful for learning about ML quantization and inference speedup.

Last updated: 2026-09-20

FP16 vs. bfloat16 structure

Both formats total 16 bits, but they split those bits between the exponent and mantissa very differently — giving each a very different representable range and precision.

Item	FP16 (IEEE 754 half precision)	bfloat16
Total bits	16	16
Exponent bits	5	8
Mantissa bits	10	7
Representable range	About ±6.1×10⁻⁵ to ±65504 (narrower range, but more mantissa bits for precision)	About ±1.2×10⁻³⁸ to ±3.4×10³⁸ (same wide range as float32, but lower precision)
Main use case	Image processing, graphics, and memory-efficient inference (half-precision training)	Deep learning training (TPUs and modern GPUs) — no need to worry about exponent overflow when converting from float32

bfloat16 shares float32's 8-bit exponent width and bias (127), which means it can be produced from a float32 value by simply truncating the mantissa — a handy implementation shortcut.

Seeing how the bits are laid out in FP16 and bfloat16

Though both occupy sixteen bits, FP16, that is IEEE 754 binary16, and bfloat16 apportion those bits in quite different ways. This tool converts between decimal values and bit patterns and colours the sign, the exponent and the significand separately, so that the difference can be seen rather than merely read about.

**The point lies in the apportionment. FP16 gives five bits to the exponent and ten to the significand, whereas bfloat16 gives eight to the exponent and seven to the significand.** Eight exponent bits is exactly what single precision uses, and two properties follow from that. The first is that **bfloat16 spans the same range of values as FP32**, and the second is that **converting from FP32 amounts to truncating to the upper sixteen bits.** That is why machine learning favours bfloat16: there is far less risk of a value flying out of range and wrecking a training run. The price is a significand of only seven bits, so **precision is coarser than FP16's.** Choose FP16 where precision matters and bfloat16 where range does.

How to use it

Choose the direction of conversion Decimal to bits and bits to decimal are both available.
Enter a value A decimal number or a string of ones and zeroes will serve equally.
Read the coloured bits **The sign, the exponent and the significand are each shown in their own colour.**
Set FP16 against bfloat16 **Representing the same value in both formats shows exactly where they part company.**

Tips for getting more out of it

Even for the same value like 0.1, FP16 and bfloat16 round it very differently. Switch formats and compare the mantissa bit patterns.
Because bfloat16 shares float32's exponent width and bias, it resists overflow even for large values above 65504. FP16, by contrast, overflows to infinity as soon as you exceed 65504.
Converting "70000" to FP16 overflows to infinity, while bfloat16 represents it fine (with reduced precision).
When quantizing models in frameworks like PyTorch or TensorFlow, bfloat16 converts easily from float32, while FP16's narrower range sometimes requires pre-scaling.
To convert bits back to decimal, enter a 4-digit hex value with a `0x` prefix, or a 16-digit binary value (the `0b` prefix is optional).

Where it comes in useful

Understanding what quantisation costs

**You can establish concretely how far a value is rounded when a model is dropped to sixteen bits.**

Deciding between the formats

It gives you the material to weigh whether your case needs range or precision.

Finding where overflow begins

**You can try, with real values, what happens once FP16's largest representable number is exceeded.**

Learning how floating point works

You can follow, bit by bit, how an exponent and a significand combine to express a single number.

Floating-point terms

Sign bit: The single highest bit, giving the sign: 0 for positive and 1 for negative.
Exponent: The part expressing the magnitude of the value. **FP16 allots five bits to it and bfloat16 eight.**
Significand: The part corresponding to the significant figures. **FP16 has ten bits and bfloat16 seven, and that gap is precisely the difference in precision.**
Bfloat16: **A sixteen-bit format that keeps the exponent at FP32's eight bits.** It halves the storage without sacrificing range.
Subnormal number: The representation used when the exponent is at its smallest, allowing values extremely close to zero.
Quantisation: The practice of expressing a model's weights in fewer bits. **Storage and computation fall, and precision falls with them.**

Frequently asked questions

Both total 16 bits, but FP16 (IEEE 754 half precision) uses 5 exponent bits and 10 mantissa bits, while bfloat16 uses 8 exponent bits and 7 mantissa bits. FP16's extra mantissa bits give it higher precision but a narrower range; bfloat16 trades precision for float32's wide range.

During deep learning training, gradients and parameters can swing between extremely large and extremely small values. bfloat16 keeps float32's wide representable range (resisting overflow/underflow) while cutting memory and compute roughly in half. FP16's narrower range can overflow more easily, sometimes requiring extra loss scaling during training.

About 65504. Converting anything larger to FP16 overflows to infinity. bfloat16, sharing float32's exponent width, can represent values up to about 3.4×10³⁸.

A bit pattern where the exponent is all zero but the mantissa is non-zero. Regular (normal) floating-point numbers have an implicit leading 1 on the mantissa; subnormals omit it, allowing values even closer to zero than the smallest normal number — at the cost of precision.

bfloat16 exactly matches float32's exponent width (8 bits) and bias (127), so conversion is just a matter of keeping the top 7 mantissa bits from the float32 pattern (with rounding) — no exponent recalculation or range check needed, which keeps the implementation simple.

Side Note — Why machine learning wanted a "less precise" number format

Around 2018, Google devised a new 16-bit floating-point format called bfloat16 for its Tensor Processing Units (TPUs). FP16 (IEEE 754 half precision) already existed and was in practical use in image processing and graphics, but its mere 5 exponent bits gave it a narrow representable range — a poor fit for the vanishing and exploding gradients that show up during deep learning training.

bfloat16's design idea is straightforward: sacrifice mantissa precision, but keep the exponent exactly as wide as float32's 8 bits, so the extremely large and small values that crop up during training can be handled safely. The name "Brain Floating Point" comes from Google Brain, the machine learning research team that created it.

In conventional computer science, reducing floating-point precision has long been treated as a breeding ground for bugs. But deep learning models have an unusual property: modest numerical error rarely hurts the final prediction accuracy much. Turning that "somewhat inaccurate but still works overall" property to its advantage — and cutting memory and compute cost in half with a 16-bit format — represents an optimization distinctly at home in machine learning, quite apart from traditional computer science wisdom.

Browse all trivia