aliteq.

What is MXFP4? The 4-bit format gpt-oss ships in, explained

MXFP4 stores AI model weights in 4 bits, with one shared scale per block of 32 values. Why OpenAI shipped gpt-oss in it, how it differs from NVFP4, FP8 and GGUF Q4, and which GPUs run it natively.

Aliteq TeamPublished 9 min read
Mathematical equations on a dark background, representing quantization math, with a plain-text NVIDIA name badge in the top right

Some links on this page are referral links: we may earn a commission, at no cost to you.

Share

MXFP4 is a 4-bit floating-point format from the Open Compute Project's Microscaling (MX) specification: each value is a 4-bit E2M1 number, and every block of 32 values shares one 8-bit power-of-two scale (E8M0), for about 4.25 bits per value. It is the format OpenAI shipped gpt-oss-20b and gpt-oss-120b in, which is why gpt-oss-120b fits on a single 80GB GPU. NVIDIA Blackwell GPUs and AMD's Instinct MI355X run MXFP4 math natively; older GPUs can still load MXFP4 weights but compute in 16-bit.

What is MXFP4

MXFP4 is short for "microscaling FP4". The microscaling idea is simple: 4-bit numbers can only represent a handful of values, so instead of storing each weight's size directly, you split the weights into small blocks and give each block its own scale factor. The value you actually use is the 4-bit number multiplied by its block's scale.

The OCP MX v1.0 spec (2023) defines a family of these formats, all with the same block size and the same kind of scale. The table below is from the MX paper by engineers at Microsoft, AMD, Intel, Meta, NVIDIA and Qualcomm.

MXFP8

Value type
FP8 (E4M3 or E5M2)
Bits per value
8
Values per block
32
Shared scale
E8M0

MXFP6

Value type
FP6 (E2M3 or E3M2)
Bits per value
6
Values per block
32
Shared scale
E8M0

MXFP4

Value type
FP4 (E2M1)
Bits per value
4
Values per block
32
Shared scale
E8M0

MXINT8

Value type
INT8
Bits per value
8
Values per block
32
Shared scale
E8M0

E8M0 means the scale is 8 bits of exponent and no mantissa, so it can only be a power of two (..., 0.5, 1, 2, 4, ...). One 8-bit scale shared by 32 values adds a quarter of a bit per value, which is where the 4.25 bits per parameter in Ollama's gpt-oss post comes from. Compared with 16-bit weights, that is about 3.8 times smaller (our arithmetic).

What is FP4

FP4 is any 4-bit floating-point number, and the common layout, E2M1, has 1 sign bit, 2 exponent bits and 1 mantissa bit. That gives only 16 codes: zero and the values 0.5, 1, 1.5, 2, 3, 4 and 6, positive and negative. On its own that is far too coarse for model weights, which is why every practical FP4 format (MXFP4, NVFP4) adds a shared scale per block. When someone says a GPU "supports FP4", they mean its Tensor Cores or matrix cores can multiply these 4-bit values directly. NVIDIA's blog lists three 4-bit formats Blackwell supports: plain FP4, MXFP4 and NVFP4.

Why gpt-oss ships in MXFP4

OpenAI's model card says the gpt-oss models "were post-trained with MXFP4 quantization of the MoE weights", making gpt-oss-120b "run on a single 80GB GPU (like NVIDIA H100 or AMD MI300X)" and gpt-oss-20b "run within 16GB of memory". It also says all of its published evaluations used the same MXFP4 weights, so the benchmark scores are the scores of the 4-bit model you download, not of a bigger original.

The mixture-of-experts layers hold most of the model. Per Ollama's gpt-oss post (August 5, 2025), those weights are over 90% of the parameter count, so putting them in 4.25 bits shrinks the whole download. On Hugging Face on November 17, 2026, the safetensors files were 13.8 GB for gpt-oss-20b and 65.2 GB for gpt-oss-120b. The rest stays in BF16; the Hugging Face file listing shows only BF16 and packed 4-bit tensors.

Can your card run it? Can you run gpt-oss-20b locally answers that card by card, and gpt-oss-120b's hardware requirements covers the big one. Live VRAM numbers are on cost to run gpt-oss-20b and gpt-oss-120b.

MXFP4 vs NVFP4 vs FP8 vs GGUF Q4

MXFP4 and NVFP4 are close cousins. NVFP4 is NVIDIA's own variant: blocks of 16 instead of 32, an FP8 E4M3 scale that can take fractional values instead of a power of two, plus one FP32 scale per tensor. NVIDIA's blog lists MXFP4 with a "risk of noticeable accuracy drop compared to FP8", which is the gap NVFP4 was built to close. For the full NVFP4 story (accuracy, speed, how to run and quantize it), see what NVFP4 is; this page doesn't repeat it.

Who defines it

MXFP4
Open Compute Project (open spec)
NVFP4
NVIDIA
FP8 (E4M3)
Industry standard
GGUF Q4_K_M
llama.cpp

Values per scale

MXFP4
32
NVFP4
16
FP8 (E4M3)
per tensor or block
GGUF Q4_K_M
32, in super-blocks of 256

Scale type

MXFP4
E8M0 (power of two)
NVFP4
FP8 E4M3 + FP32 per tensor
FP8 (E4M3)
FP32
GGUF Q4_K_M
6-bit scale and min

Bits per value

MXFP4
~4.25
NVFP4
~4.5
FP8 (E4M3)
8
GGUF Q4_K_M
~4.85 in llama.cpp

Native hardware

MXFP4
NVIDIA Blackwell, AMD MI355X
NVFP4
NVIDIA Blackwell
FP8 (E4M3)
Ada, Hopper, Blackwell, AMD MI355X
GGUF Q4_K_M
none needed

Known release

MXFP4
gpt-oss-20b, gpt-oss-120b
NVFP4
nvidia/*-NVFP4 repos
FP8 (E4M3)
many official FP8 releases
GGUF Q4_K_M
community builds of most models

The short version: MXFP4 is the open, slightly cheaper-to-store format; NVFP4 is NVIDIA's more accurate 4-bit; FP8 is the safe middle ground; and a GGUF Q4 file runs on anything, including CPUs and Macs. If you are new to all this, what quantization is explains the idea, and how to quantize a model to GGUF shows the everyday route.

Which GPUs run MXFP4 natively

Native means the GPU multiplies the 4-bit values in hardware, which is where the speed comes from.

  • NVIDIA Blackwell: NVIDIA's blog lists MXFP4 among the 4-bit formats Blackwell supports. That covers the RTX 50 series such as the RTX 5090, the RTX PRO 6000 Blackwell, DGX Spark and the data-center B200.
  • AMD Instinct MI355X: AMD's product page lists "expanded MXFP6 and MXFP4 datatype support", 288GB of HBM3E and a peak of 10.1 PFLOPs of MXFP4 matrix math (read November 17, 2026).

What happens on older GPUs

MXFP4 models still run, just without the 4-bit math. vLLM's docs list its Marlin FP4 kernels for Ampere, Ada and Hopper cards (Turing is excluded for MXFP4) and say Marlin "always runs with 16-bit activations": the weights stay small in memory, the multiply happens in 16-bit. llama.cpp defines an MXFP4 tensor type (GGML_TYPE_MXFP4), and Ollama's gpt-oss post says it supports "the MXFP4 format natively without additional quantizations or conversions", with new kernels in its engine. That is why gpt-oss-20b runs on an RTX 4090, an RTX 3090 or a 16GB card at all. OpenAI's card itself names the H100 (Hopper) and MI300X as single-GPU options for gpt-oss-120b, and neither has FP4 math.

So on an older card you keep MXFP4's memory saving, and the speed is whatever your card does at 16-bit. On Blackwell you get both.

What is MXFP8

MXFP8 is the 8-bit member of the same family: FP8 values (E4M3 or E5M2) in blocks of 32 with the same E8M0 scale, per the MX paper's table. It keeps twice the bits of MXFP4 per value, with the same 32-value block scaling. AMD's MI355X page lists 5 PFLOPs of peak MXFP8 matrix math, half its MXFP4 figure. You can also meet it as a download: Ollama's library listed a qwen3.8:27b-mxfp8 tag (30GB, an MLX build) on November 17, 2026, next to its NVFP4 tags, and our Qwen3.8 27B NVFP4 guide shows how that 27B model's 4-bit and 8-bit builds compare.

No Blackwell card? Rent one

To see gpt-oss run with native MXFP4 math, you need Blackwell. An RTX 5090 holds gpt-oss-20b with plenty of room. On Vast.ai, Nov 17, 2026, RTX 5090 offers started at $0.38 an hour (median $0.71); for gpt-oss-120b's 65GB you need an 80GB-class card, where H100 SXM offers started at $1.53 an hour that day. Live prices are on our cloud GPU price page.

Thinking about buying instead? What an RTX 5090 costs today and RTX PRO 6000 prices cover the two Blackwell cards most people weigh, and rent vs buy works out when owning wins.

This guide is part of our How much VRAM do you need to run an AI model guide. Related guides: Can gpt-oss-20b run on an 8GB or 12GB GPU? Yes, with --n-cpu-moe, Run a 120B MoE on an 8-24GB GPU with llama.cpp --n-cpu-moe, Out of memory at long context.

MXFP4 questions

What is MXFP4 in simple terms?
A way to store an AI model's weights in 4 bits each. Values are grouped in blocks of 32, and each block shares one 8-bit scale that can only be a power of two. It comes from the Open Compute Project's Microscaling (MX) spec and averages about 4.25 bits per value.
What is the difference between MXFP4 and NVFP4?
Both use 4-bit E2M1 values with a shared block scale. MXFP4 uses blocks of 32 and a power-of-two E8M0 scale; NVFP4, NVIDIA's variant, uses blocks of 16, an FP8 E4M3 scale and an extra FP32 scale per tensor. NVFP4 is a little bigger (about 4.5 bits per value) and, per NVIDIA, closer to FP8 accuracy.
Why does gpt-oss use MXFP4?
OpenAI post-trained gpt-oss with its mixture-of-experts weights in MXFP4 so that gpt-oss-120b fits on a single 80GB GPU and gpt-oss-20b runs in 16GB of memory. Those MoE weights are over 90% of the parameters, per Ollama's gpt-oss post.
Which GPUs support MXFP4?
In hardware, NVIDIA Blackwell (RTX 50 series, RTX PRO 6000 Blackwell, DGX Spark, B200) and AMD's Instinct MI355X. Older NVIDIA cards such as the RTX 3090, RTX 4090 and H100 run MXFP4 models through software kernels with 16-bit math.
Can I run MXFP4 models on an RTX 4090 or 3090?
Yes. vLLM's Marlin kernels, llama.cpp and Ollama all run MXFP4 weights on Ampere and Ada cards. You keep the small file size; the math runs in 16-bit, so there is no 4-bit speedup.
Is MXFP4 better than GGUF Q4_K_M?
Neither is better everywhere. MXFP4 is slightly smaller (about 4.25 vs about 4.85 bits per value) and runs natively on Blackwell, and for gpt-oss it is the official format OpenAI evaluated. GGUF Q4_K_M is the community 4-bit format that runs on any GPU, CPU or Mac.
What is MXFP8?
The 8-bit member of the MX family: FP8 values in blocks of 32 with the same power-of-two scale. It is twice the size of MXFP4 per value.

MXFP4 is the open 4-bit format, NVFP4 is NVIDIA's tighter version of the same idea, and both pay off fully only on hardware that does 4-bit math. For everything NVFP4, from supported cards to running and quantizing models, read what NVFP4 is.

Found this useful? Share it

Share

Aliteq

Aliteq Team

Aliteq started in 2019 as a PC hardware shop and is now a US-based publication. We build the VRAM and cost calculators on this site, track live cloud-GPU prices, and write guides with AI-assisted drafting that we check against primary sources before publishing.

Work out the hardware

GPUs in this article

Specs, the AI models each one runs, and where to buy or rent it.

Email list

Local AI, only the changes that matter

A new model your GPU can actually run, a GPU price move worth acting on, or a fix that saves you an evening. Nothing in between.

Written and sent by hand. One-click unsubscribe in every email. Emails may contain referral links.

Keep reading