# I Unlocked BF16 on an RTX 4090 and Compared It to an RTX 5090 (on Windows 11) — retained record

> Retained reddit record from reddit:StableDiffusion.

Canonical: https://highsignal.app/data/records/98b9710810aa435b

[← sources](https://highsignal.app/data)


source: [reddit](https://highsignal.app/data/reddit) (reddit:StableDiffusion)  published 2026-10-31 07:12 ingested 2026-11-01 02:38

[original source ↗](https://www.reddit.com/r/StableDiffusion/comments/1xk3n70/i_unlocked_bf16_on_an_rtx_4090_and_compared_it_to/)

## retained text



```
Using MarvinFS’s tool, I successfully unlocked BF16 on the RTX 4090 running Windows 11.

[https://github.com/MarvinFS/rtx4090-uefi/releases](https://github.com/MarvinFS/rtx4090-uefi/releases)

It was very easy, so if you have an RTX 4090 whose manufacturer’s warranty has expired, why not give it a try?

I tested several image and video generation tasks using ComfyUI and compared the results with those of the RTX 5090, as shown below.

|Hardware & Software|Detail|
|:-|:-|
|CPU|Ryzen 7 9800X3D|
|RAM|DDR5-5600 192GB|
|SSD|WD Black SN850X 8TB|
|OS|Windows 11 25H2 Pro|
|Driver|GeForce Game Ready Driver 610.88|
|ComfyUI|v0.43.0 / python 3.13 / cu132|
|Startup Flags|\--use-sage-attention --fast|

All results were obtained using the same GeForce driver and the same computer.

# SDXL

|GPU|Generate|Speed|
|:-|:-|:-|
|RTX 5090|23.15 sec|12.10 it/s|
|RTX 4090 Unlock|27.62 sec|10.14 it/s|
|RTX 4090 Unlock(no --fast)|30.21 sec|9.27 it/s|
|RTX 4090|30.11 sec|9.30 it/s|

* prefectIllustriousXL\_v10.safetensors (BF16)
* 832 x 1216 @ 28 steps x 10 counts

# Anima

|GPU|Generate|Speed|
|:-|:-|:-|
|RTX 5090|44.06 sec|5.67 it/s|
|RTX 4090 Unlock|62.35 sec|4.01 it/s|
|RTX 4090 Unlock(no --fast)|56.59 sec|4.42 it/s|
|RTX 4090|62.65 sec|3.99 it/s|

* anima-base-v1.0.safetensors (BF16)
* 832 x 1216 @ 25 steps x 10 counts

# Krea2

|GPU|Generate|Speed|
|:-|:-|:-|
|RTX 5090|128.8 sec|1.16 it/s|
|RTX 4090 Unlock|180.1 sec|0.83 it/s|
|RTX 4090 Unlock(no --fast)|211.5 sec|0.71 it/s|
|RTX 4090|182.1 sec|0.82 it/s|

* krea2\_raw\_bf16.safetensors (BF16)
* qwen3vl\_4b\_bf16.safetensors
* 832 x 1216 @ 18+12 steps x 5 counts

# Qwen Image 2.1

|GPU|Generate|Speed|
|:-|:-|:-|
|RTX 5090|96.8 sec|2.07 it/s|
|RTX 4090 Unlock|116.6 sec|1.72 it/s|
|RTX 4090 Unlock(no --fast)|116.9 sec|1.71 it/s|
|RTX 4090|130.6 sec|1.53 it/s|

* qwen\_image\_2.1\_bf16.safetensors (BF16)
* qwen3vl\_8b\_bf16.safetensors
* 1024 x 1536 @ 40 steps x 5 counts

# MOSS Image BF16

|GPU|Generate|Speed|
|:-|:-|:-|
|RTX 5090|98.4 sec|2.54 it/s|
|RTX 4090 Unlock|128.3 sec|1.95 it/s|
|RTX 4090 Unlock(no --fast)|128.0 sec|1.95 it/s|
|RTX 4090|142.5 sec|1.75 it/s|

* moss\_image\_base\_bf16.safetensors (BF16)
* qwen3.5\_9b\_bf16.safetensors
* 1024 x 1536 @ 50 steps x 5 counts

# MOSS Image INT8

|GPU|Generate|Speed|
|:-|:-|:-|
|RTX 5090|42.4 sec|5.89 it/s|
|RTX 4090 Unlock|58.8 sec|4.25 it/s|
|RTX 4090 Unlock(no --fast)|58.5 sec|4.27 it/s|
|RTX 4090|59.1 sec|4.23 it/s|

* moss\_image\_base\_int8\_convrot.safetensors (INT8)
* qwen3.5\_9b\_bf16.safetensors
* 1024 x 1536 @ 50 steps x 5 counts

# MiniMax H3

|GPU|Generate|Speed|
|:-|:-|:-|
|RTX 5090|86.1 sec|0.23 it/s|
|RTX 4090 Unlock|105.0 sec|0.19 it/s|
|RTX 4090 Unlock(no --fast)|104.5 sec|0.19 it/s|
|RTX 4090|115.7 sec|0.17 it/s|

* minimax\_h3\_fl2va\_pruned\_bf16.safetensors (BF16)
* qwen3vl\_32b\_minimax\_h3\_int8\_convrot.safetensors
* minimax\_h3\_video\_vae\_int8\_convrot.safetensors
* 864 x 480 @ 20 steps x 1 counts

On average, I achieved a speed improvement of about 10%. The reason the performance didn’t improve as much as I expected is that the BF16 model is very large. When it doesn’t fit entirely into VRAM, some of the weights are offloaded to system memory. Since the RTX 4090 uses a PCIe Gen4 x16 interface, the bandwidth during offloading becomes a bottleneck.

So, how about LoRA training? Using the OSTRIS's AI-Toolkit, we performed 1,000 training steps on the MOSS Image Base BF16 dataset.

|GPU|Training|Speed|
|:-|:-|:-|
|RTX 5090|1521 sec|0.66 it/s|
|RTX 4090 Unlock|1789 sec|0.56 it/s|
|RTX 4090|1932 sec|0.52 it/s|

* moss\_image\_base\_bf16.safetensors (BF16)
* qwen3.5\_9b\_int8\_convrot.safetensors
* 512 \~ 1024 px @ 1000 steps x 1 batch

Even with LoRA training, the speed improvement was limited to about 8%. Recent MMDiT models are simply too large. Even though unlocking significantly increases BF16 throughput, the critical weights still don’t fit entirely.

The measured GEMM throughput values are as follows:

|GPU|RTX 4090|RTX 4090 Unlock|RTX 5090|
|:-|:-|:-|:-|
|f16/f16|307.4 TF/s|312.4 TF/s|429.9 TF/s|
|f16/f32|160.5 TF/s|312.8 TF/s|223.8 TF/s|
|bf16/f32|160.1 TF/s|328.7 TF/s|223.1 TF/s|
|s8/s32|641.6 TF/s|657.6 TF/s|446.5 TF/s|
|dp4a|163.6 TF/s|163.5 TF/s|224.2 TF/s|
|ffma|78.7 TF/s|78.7 TF/s|108.4 TF/s|

Approximately a 100% performance increase for both FP16 with FP32 accumulate and BF16 with FP32 accumulate.

|mode|RTX 4090|RTX 4090 Unlock|
|:-|:-|:-|
|fp8 4096^(3)|326.4 TF/s|521.8 TF/s|
|fp8-fast 4096^(3)|343.0 TF/s|554.8 TF/s|
|Int8 4096^(3)|555.0 TF/s|557.6 TF/s|
|Bf16 4096^(3)|174.8 TF/s|319.8 TF/s|
|Fp16 4096^(3)|175.2 TF/s|234.0 TF/s|
|fp8 8192^(3)|**342.8 TF/s**|**544.4 TF/s**|
|fp8-fast 8192^(3)|352.2 TF/s|582.5 TF/s|
|Int8 8192^(3)|**614.2 TF/s**|**607.5 TF/s**|
|Bf16 8192^(3)|173.8 TF/s|203.2 TF/s|
|Fp16 8192^(3)|176.9 TF/s|279.7 TF/s|
|fp8\_f32|**328.5 TF/s**|**654.9 TF/s**|
|fp8\_f16|654.7 TF/s|655.0 TF/s|

There was no change at all for INT8, but FP8 saw a performance improvement of approximately 60–100%.

How were your results? 🤔

If anyone has actually tried unlocking, please share your thoughts.
```



document fetched 2026-11-01 00:30 · canonical https://reddit.com/r/StableDiffusion/comments/1xk3n70/i_unlocked_bf16_on_an_rtx_4090_and_compared_it_to
