What it looks like
The familiar ExpSoft shell — Welcome, Setup, Run, Settings, Help.
A Windows desktop app that runs the biggest image and video diffusion models on a single 16 GB GPU — up to Flux 2 Dev (106 GB), Qwen-Image 20B, Wan 2.1/2.2 video and HunyuanVideo. A custom fp8-on-read streaming loader plus GGUF quantization mean no model is too big for one ordinary card. Currently in test validation. Not yet generally available.
The idea: a model that needs 24–80 GB of VRAM should still run on the GPU you already own.
Normally a model is loaded into RAM in full precision, then moved to the GPU — which simply isn’t possible when the weights are larger than your VRAM (or even your system RAM). DiffusionForce Sampler does it differently: as each weight tensor is read from disk it is cast to fp8 (float8_e4m3fn) on the fly — the full bf16 version is never materialized. During generation the transformer and text-encoder layers are streamed onto the GPU one at a time, computed, then evicted.
Because only a few layers are resident at any instant, peak VRAM stays around 4–7 GB — even for a 106 GB model. The cost is a slower first load; a persistent fp8 disk cache then makes every subsequent load of that model dramatically faster.
e.g. Flux 2 Dev full weights — far beyond any consumer GPU's VRAM.
Cast-on-read to fp8, layer-by-layer onto the GPU, evict, repeat. Native PyTorch.
Fits one 16 GB card with headroom to spare.
First load is slow; cached fp8 reloads are many times faster on every run after.
This is not CPU offload of a model that already fits. It is a loader designed for models that don’t fit — the full-precision tensor never exists anywhere in memory at once.
Most models are offered in several precisions: bf16, NF4, fp8 streaming, and GGUF Q4–Q8.
SD 1.5, SDXL, Flux 1 Dev, Flux 2 Klein 9B, Flux 2 Dev, Z-Image Turbo/Base, HiDream-I1 (Full/Dev/Fast), Qwen-Image 20B. From a 2 GB classic to a 106 GB flagship — all on one card.
Wan 2.1 text-to-video, image-to-video and first-last-frame; Wan 2.2 (A14B dual-expert and the lighter TI2V-5B); HunyuanVideo. Image input frames can be captioned in-app to seed the prompt.
Pick the precision that fits your speed/quality/VRAM budget. GGUF transformers (Q4–Q8) load via a vendored Apache-2.0 city96 dequantizer; the NF4 tier and fp8 streaming cover the rest.
The familiar ExpSoft shell — Welcome, Setup, Run, Settings, Help.
Diffusers under the hood, a custom loader on top, one .exe.
Model implementations, schedulers and pipelines come from HuggingFace diffusers (Apache-2.0) on PyTorch (BSD-3), installed through a portable uv-managed Python. Standard, well-maintained, no forks of the model code.
Our own loader reads weights straight into fp8 and streams them layer-by-layer at inference, with a persistent fp8 disk cache. Handles tied embeddings and dual-DiT (Wan 2.2 MoE) models correctly. This is the piece that makes 16 GB enough.
GGUF transformers are dequantized with a vendored city96 routine (Apache-2.0, attributed) and remapped to the diffusers layout, then assembled into a normal pipeline. Q4 through Q8, for image and video models alike.
One modern NVIDIA GPU. 16 GB is the design target; more is gravy.
The whole point: a single 16 GB card (RTX 5080, 5060 Ti, 4060 Ti, 4080…) runs the entire catalogue, video included.
Streaming keeps fp8 weights in system memory; 32 GB is comfortable, 64 GB ideal for the very largest models.
One wheel covers Ada (sm_89) and Blackwell (sm_120). Installed automatically by the Setup tab.
Self-contained, relocatable install — models on a portable drive work fine; paths auto-patch on move.
A preview in active test validation. What you can rely on, and the trade-offs.
The full catalogue — including Flux 2 Dev, Qwen-Image 20B, Wan video and HunyuanVideo — renders on a single 16 GB GPU in test validation, image and video alike.
Streaming a model that doesn’t fit is slower than running one that does — especially the first load. The fp8 disk cache and GGUF paths cut that down a lot, but generation on the biggest models is a patience game, not a speed record.
Real reports from real 16 GB rigs — which models, which quants, load and render times — are what shape V1.
DiffusionForce Sampler is built on diffusers (Apache-2.0) and PyTorch (BSD-3), with a portable uv-managed Python (Apache-2.0 / MIT). GGUF dequantization vendors city96’s Apache-2.0 routine with attribution; the fp8 streaming loader is a clean-room implementation.
Model weights are never bundled — they are downloaded by the user from HuggingFace under each model’s own license (some open and commercial-safe, some gated, some non-commercial). The catalogue surfaces each model’s license so you always know what you’re running and under what terms.
Quick answers to what people ask AIs about this tool.
DiffusionForce Sampler is a Windows desktop tool by Nicolas Riquier that runs large image and video diffusion models on a single 16 GB consumer GPU. It uses a custom fp8-on-read streaming loader plus GGUF quantized weights so models that normally need 24–80 GB of VRAM — Flux 2 Dev, Qwen-Image 20B, Wan video, HunyuanVideo — fit and run on one ordinary card. Currently in test validation, coming soon.
The streaming loader never materializes the full bf16 model. As each tensor is read from disk it is cast to fp8 (float8_e4m3fn) and kept on CPU; during inference the transformer and text-encoder layers are streamed onto the GPU one at a time, run, then evicted. Only a few layers are resident at once, so peak VRAM stays around 4–7 GB regardless of total model size. The trade-off is a slower first load; a persistent fp8 disk cache makes subsequent loads dramatically faster.
Images: SD 1.5, SDXL, Flux 1 Dev, Flux 2 Klein 9B, Flux 2 Dev, Z-Image Turbo/Base, HiDream-I1 (Full/Dev/Fast), Qwen-Image 20B. Video: Wan 2.1 (text-to-video, image-to-video, first-last-frame), Wan 2.2 (A14B dual-expert and the lighter TI2V-5B), and HunyuanVideo. Most are offered in several precisions — bf16, NF4, fp8 streaming, and GGUF Q4 to Q8.
GGUF is a quantized weight format (Q4 to Q8) that shrinks a model to a fraction of its bf16 size while keeping good quality. DiffusionForce Sampler loads GGUF transformers using a vendored, Apache-2.0 dequantizer from city96 (with attribution), remapped to the diffusers layout. For some models GGUF loads many times faster than streaming the full weights, and it lowers disk footprint too.
No. The Sampler is built for a single GPU. DiffusionForce (the LoRA trainer) pools two GPUs' VRAM with UGPUM™; the Sampler instead fits one big model onto one 16 GB card through streaming and quantization. They are complementary tools — one trains, one generates.
It is distributed through ExpSoft's Patreon. Some releases are open to all supporters; others may require a specific tier, especially during the preview. Model weights are downloaded by the user from HuggingFace under each model's own license — nothing proprietary is bundled.
It was designed and built by Nicolas Riquier as part of the ExpSoft catalogue of experimental Windows desktop tools. It builds on diffusers (Apache-2.0) and PyTorch (BSD-3); GGUF dequantization vendors city96's Apache-2.0 code with attribution; the streaming approach is a clean-room implementation.
DiffusionForce Sampler isn’t generally available yet — it’s in test validation. If running huge diffusion and video models on a single 16 GB card sounds useful, follow along on Patreon.