Minifloat Format Converter

Introduction

Minifloats are a bunch of different floating point formats, like your standard IEEE-754 float32, but smaller!

Each of them makes the delicate trade off between bandwidth, computing cost and precision.
No one format can claim to dominate the others in every situation.

They can roughly be categorised into two use cases: Rendering (VFX and Games) and Machine Learning. However with things like D3D12 LinAlg, it probably won't be long until games start using neural networks (with these formats) alongside traditional rendering techniques.

The (s.e.m) notation you might see in this e.g (1.8.7) means (sign.exponent.mantissa) in terms of bits.
So (1.8.7) means (1 sign bit, 8 exponent bits, 7 mantissa bits) and really acts as a shorthand way of identifying the shape of a floating point format.

16bit formats

bfloat16 (1.8.7)

Shortened IEEE 754 single-precision floating-point format. (Has the same exponent as a f32, but less mantissa bits).

A de facto standard for LLM training, where it can be used for gradients, activations and weights.

Can be converted into a f32 by simply shifting.

float f = asfloat((uint32_t)bfloat16_bits << 16);

f16 (half, 1.5.10)

Probably the third most widely used format globally, after f32 and f64.

In games, it's commonly used for storing the pre-tonemapped render target alongside HDR textures.

In VFX, you'd output render passes for compositing in this format.

On GPUs you would expect to see dedicated f32tof16 / f16tof32 instructions.
Additionally many GPUs can perform arithmetic directly on f16 values (usually packing two in a 32bit register).

8bit formats

fp8 (1.5.2)

Shortened IEEE 754 half-precision binary floating-point format. (Has the same exponent as a f16, but less mantissa bits).

Can be converted into a f16 by simply shifting.

half h = ashalf((uint16_t)fp8_bits << 8);

e5m2 (OCP-E5M2, 1.5.2)

Part of the OFP8 specification, targeting machine learning.

Has larger range than e4m3, making it useful for gradients.

Stored the same as fp8, but with OFP8 saturation applied when converting from another format.

• Saturate: Clamp to the max magnitude.
• NonSaturate: Greater than max magnitude becomes infinity.

e5m2fnuz (1.5.2)

FNUZ (Float NaN Unsigned Zero) variant of e5m2.

Supported primarily today by AMD hardware (MI300).

Uses a bias of 16 (1 more than e5m2) for the exponent.

Has no dedicated infinity, with NaN being 0x80 (-0). Removing +/- infinity and 6 NaN bit-patterns in favour of a single NaN, it has 8 more unique values.

As there is no infinity to overflow to, values beyond the maximum magnitude always saturate.

e4m3 (OCP-E4M3, 1.4.3)

Part of the OFP8 specification, targeting machine learning.

Has higher precision than e5m2, making it useful for activations and weights.

Has no dedicated infinity, with NaN being 0xff / 0x7f.

Like e5m2 has saturating modes:

• Saturate: Clamp to the max magnitude.
• NonSaturate: Greater than max magnitude becomes NaN.

e4m3fnuz (1.4.3)

FNUZ (Float NaN Unsigned Zero) variant of e4m3.

Supported primarily today by AMD hardware (MI300).

Uses a bias of 8 (1 more than e4m3) for the exponent.

Has no dedicated infinity, with NaN being 0x80 (-0). By reducing the 2 NaN values to 1 and removing -0, it has 2 more unique values.

As there is no infinity to overflow to, values beyond the maximum magnitude always saturate.

e8m0 (OCP-MX-E8M0, 0.8.0)

Part of the OCP-MX specification, targeting machine learning and designed to be used as part of a block with a shared scaling factor.

Only has positive powers of 2 and scales from 2⁻¹²⁷ (0x00) to 2¹²⁷ (0xfe), with NaN being specifically at 0xff.

Has no dedicated Infinity or 0.

6bit formats

e3m2 (OCP-MX-E3M2, 1.3.2)

Part of the OCP-MX specification, targeting machine learning and designed to be used as part of a block with a shared scaling factor.

Much like how e5m2 relates to e4m3, e3m2 relates to e2m3 (has a larger range).

Has no dedicated Infinity or NaN.

e2m3 (OCP-MX-E2M3, 1.2.3)

Part of the OCP-MX specification, targeting machine learning and designed to be used as part of a block with a shared scaling factor.

Has more precision than e3m2, but has less range.

Has no dedicated Infinity or NaN.

4bit formats

e2m1 (OCP-MX-E2M1)

Part of the OCP-MX specification, targeting machine learning and designed to be used as part of a block with a shared scaling factor.

Despite its small size, the accuracy scores compared to e4m3 formats, when used as part of a microscaling block, are impressive.

Has no dedicated Infinity or NaN.

binary4p2sf

The same as e2m1, but -0 is replaced with NaN.

binary4p2se

The same as binary4p2sf, but ±6 is replaced with ±Inf.

Other

TensorFloat-32 (1.8.10)

Shortened IEEE 754 single-precision floating-point format. (Has the same exponent as a f32, but less mantissa bits).

Widely used in NVIDIA Ampere/Hopper training, designed specifically for tensor cores.
Despite having 32 in the name, is actually 19 bits.

Can be converted into a f32 by simply shifting.

float f = asfloat(tf32_bits << 13);

E5B9G9R9 (0.5.9)

Shortened unsigned IEEE 754 half-precision binary floating-point format. (Has the same exponent as a f16, but less mantissa bits).

Colour values are stored as mantissa bits with a shared exponent.

Often used as a HDR texture format (although largely replaced by BC6).

The reasoning behind this format is that perceptually the human eye is a lot better at picking out differences in luminance than it is hue changes.
The same theory applies to formats like YCbCr, where it's not uncommon to transmit Y (luma) at a higher resolution than the chromacities (CbCr).
This idea can also be seen when storing baked lighting as L1 spherical harmonics. Rather than storing each channel as 4 coefficients, it's pretty common to construct a weighted average and normalise against L0, with additional coefficients for R, G and B (12 floats becomes 6).

Can be converted into a f16 by simply shifting.

half h = ashalf((uint16_t)e5m9_bits << 1);

R11G11B10 (0.5.6 / 0.5.5)

Shortened unsigned IEEE 754 half-precision binary floating-point format. (Has the same exponent as a f16, but less mantissa bits).

Often used in place of RGBA16f for render targets.

Can be converted into a f16 by simply shifting.

half h10 = ashalf((uint16_t)u10_bits << 5);
half h11 = ashalf((uint16_t)u11_bits << 4);

Links

• To FP8 and Back Again: Quantifying the Effects of Reducing Precision on LLM Training Stability
• NVIDIA: Floating-Point 8: An Introduction to Efficient, Lower-Precision AI Training
• NVIDIA: Introducing NVFP4 for Efficient and Accurate Low-Precision Inference
• OCP 8-bit Floating Point Specification (OFP8) - Revision 1.0
• OCP Microscaling Formats (MX) Specification - Version 1.0