NVIDIA's Sana: 1024px Image in 0.4 Seconds? I Tested It

Author: Prompt Engineer 48 · Watch on YouTube

Video authored by the channel shown, not by IANIA; all rights belong to the creator. Transcript and summary generated automatically; the original-language content is preserved.

Original language: English

Original video: NVIDIA’s Sana: 1024px Image in 0.4 Seconds? I Tested It · Channel: Prompt Engineer 48 · 08:08 · Watch on YouTube

Topics: AI evaluation and benchmarks, AI developer tools, AI content generation, AI infrastructure and hardware, Local and open-source models

Summary

The video tests NVIDIA’s Sana image models, comparing their speed and output quality on an 8 GB laptop and a rented A40 GPU. Sana Sprint generated a 1024×1024 image in 0.38 seconds on the A40, while the 0.6B model took about 21 seconds on the laptop with CPU offload. The results highlight memory limits as a major cause of the speed gap, and show that Sprint images can look close to 20-step outputs, though text rendering remains unreliable. The video also reviews other Sana features and gives setup guidance, while distinguishing the creator’s measurements from untested claims in the repository.

Key points

The repository describes Sana as a high-resolution image synthesis model using a linear diffusion transformer and lists an Apache 2.0 license.
The video explains Sana’s speed through its DCAE autoencoder, linear attention, Gemma text encoder, and Sprint distillation.
On an 8 GB RTX 4060 laptop, Sana 0.6B took about 20.6–25.9 seconds with CPU offload; running it entirely on the GPU was slower because memory use exceeded the card’s capacity.
Sana 1.6B failed to load on the laptop because of limited available system RAM.
On a rented A40, Sana Sprint 0.6B generated an image in 0.38 seconds, Sprint 1.6B in 0.47 seconds, and the 20-step 0.6B and 1.6B models in 1.57 and 2.52 seconds.
The A40 Sprint result is slower than the repository’s 0.1-second H100 claim, but the creator considers the measured result realistic for the A40.
The 20-step 1.6B model produced the cleanest examples; Sprint images were visually close at a glance, but text in images was a weak point.
The video mentions repository claims about 2K and 4K generation and an 8 GB 4-bit version, but the creator did not test them.
The creator recommends trying the 4-bit version on an 8 GB card, while noting that its speed was not tested.
The video demonstrates Diffusers setup with the BF16 model variant and recommends CPU offload when there is less than about 11 GB of free VRAM.

Chapters

Start	Chapter	Summary
00:02	Sana’s speed claims and design	The creator introduces the speed comparison, reviews the repository claims, and explains the techniques behind Sana’s efficiency.
02:11	Testing on a laptop and rented GPU	Laptop memory limits prevent fast generation, while tests on an A40 measure sub-second Sprint results and faster performance than the laptop.
04:22	Image quality and other Sana features	The video compares generated images and text rendering, then surveys additional models and tools mentioned in the repository.
06:28	Reproducing the test and verdict	The creator shares Diffusers setup guidance, summarizes hardware recommendations and benchmark results, and closes with the next video.

Quotes

This image took 0.38 seconds to make. — 00:02

Saana swaps that for linear tension, so the cost grows in a straight line — 01:39

Stable Diffusion Sprint 0.6b, two steps, 0.38 seconds. — 03:51

So, text rendering is the weak spot. — 04:54

I spent about 10 cents on this whole benchmark. — 07:34

Concepts and entities

Sana, Sana Sprint, NVlabs/Sana, NVIDIA, DCAE, Gemma, Diffusers, RunPod, A40, ComfyUI, Nunchaku, ControlNet

Full transcript (original language)

00:02 This image took 0.38 seconds to make. It’s 1024 by 1024 and the sign says Saana more or less. Now, the same model, the same size on my 8 GB gaming laptop, about 21 seconds. So, who is right? The repo that says 0.1 seconds or my laptop? Mind you, everything slow in this video ran on my own system and everything fast ran on a rented GPU that cost me 59 cents an hour. Let’s go ahead and test this out. This is the repo NVlabs/saana.

00:33 You can see about 9.3 thousand stars, 745 forks and the license on the right is Apache 2.0, so you can use it commercially. It comes from Nvidia and MIT and the description says efficient high-resolution image synthesis with a linear diffusion transformer. Now, if you look at the readme, the claim is right at the top, text-to-image up to 4K, 20 times smaller and 100 times faster than Flux 12B and the sprint version says 0.1 seconds per 1024 pixel image on an H100. One thing I want to say, honestly, if you look at the news

01:05 section, most of the recent work is video and world models, Saana video 2.0, Saana WM, Saana streaming. The image model I’m testing today is the older part of the repo from 2024 and early 2025, but it is the part that most of us can actually run. The docs page list the key techniques and there are three that matter for speed. First, the autoencoder. Normal image models compress an image eight times before the diffusion model touches it. Saana uses DCAE, which compresses 32 times, so a 1024 image becomes 32 by 32 tokens, not

01:39 128 by 128. That is 16 times fewer tokens. Second, linear tension. In a regular transformer, doubling the tokens roughly quadruples the attention cost. Saana swaps that for linear tension, so the cost grows in a straight line and the gap gets bigger the higher the resolution goes. That’s why they can talk about 4K. Third, the text encoder, instead of T5, they use a small decoder-only language model, Gemma, as the text encoder. That is what lets it follow longer prompts. And then Sprint. Sprint is distilled. So, instead of 20

02:11 steps, it makes the image in 1 to 4 steps. In my test, I used two. Here are the models on Hugging Face. I’m going to use the Diffusers versions, so I don’t have to build the whole repo. My system is a laptop with an RTX 4060 and 8 GB of VRAM and 16 GB of RAM. I installed Diffusers, loaded Stable Diffusion 0.6b, and the first download took 319 seconds. So, that’s 5 minutes just for weights. Now, the first run with CPU offload turned on, it generated in 20.6 seconds and 25.9 seconds, and peak VRAM was 5.3 GB. So, that works, but it’s nowhere

02:46 near 0.1 seconds. Maybe offload is the problem, I thought. So, I put the whole model on the GPU, and it got slower, 37 to 41 seconds per image. The reason is on screen, peak memory was 8.8 GB, and my card has eight. So, Windows spills the rest into shared memory. That is the first honest number, the 0.6b model does not fit on an 8 GB card without help. Then, I tried the bigger one, Stable Diffusion 1.6b, and it didn’t even load. I got a memory error while loading the transformer because I had about 2 GB of RAM free. I’m leaving that in because if

03:21 you have a 16 GB laptop, this might happen to you, too. So, I rented a GPU on RunPod. The first one I picked, an RTX 4090, started, but the GPU wouldn’t initialize. CUDA gave an unknown error, so I deleted it and moved on. Second pick was an A40 with 48 GB of VRAM at 59 cents an hour. I ran each model with one warm-up and then six times runs, and here are the results. Stable Diffusion Sprint 0.6b, two steps, 0.38 seconds. Every one of

03:51 the six runs was within a hundredth of a second. Stable Diffusion 1.6B 0.47 seconds. The regular models with 20 steps, SANA 0.6B takes 1.57 seconds and SANA 1.6B takes 2.52 seconds. Peak VRAM for the 1.6B is 10.9 GB. So, the claim of 0.1 seconds was on an H100. On this A40, I measured 0.38. That’s about four times slower than the H100 number, which is reasonable for an A40 and it’s real.

04:22 And compare that with the laptop, 21 to 26 seconds against 0.38. That’s more than 50 times slower. And the difference is not the model, it’s the memory. Now, one mistake of mine because I want to show it, my first 20-step run of the 1.6B model came out as this. That wasn’t SANA. I had loaded the wrong checkpoint variant, the FP16 weights in a BF16 pipeline. When I used the BF16 repo with the BF16 variant, which is what the model card says, the same prompt gave this. The sign says SANA and it’s spelled right.

04:54 Speed is only half of it. So, let’s look at the images. Same three prompts, a cyberpunk cat with a neon sign, a coffee shop at sunrise, and a red fox in snow. The 1.6B at 20 steps is the cleanest. You can see the whiskers, the wet street reflection, and the sign is spelled correctly. The Sprint 1.6B image is close, but the sign says SANA with an extra S. And on my laptop, Sprint 0.6B wrote SANA with an extra A. So, text rendering is the weak spot. For a single

05:25 word, it mostly works, but I wouldn’t trust it with a full sentence. For pictures without text, the Sprint model at 0.4 seconds is honestly hard to tell from the 20-step model at a glance. Before the verdict, let me show you what else you get because the repo is bigger than one model. All of this is from the readme news list. There’s a 2K model that the readme says makes an image in about 4 seconds and a 4K model that makes a 4096 by 4096 image in about 20 seconds. Those are their numbers, not mine, and I did not run 4K, so treat

05:58 that as a claim. There’s a 4-bit version. The news section says you can run Stable Diffusion inside 8 GB of VRAM using SVD quant and the Nunchaku engine. Again, I haven’t tested it, but if you own an 8 GB card, that is the first thing I would try. There’s Stable Diffusion 1.5, which is about scaling. They train a bigger model more efficiently, and they add inference scaling, so you can spend more compute at generation time for a better image. And there’s a ControlNet version, so you can guide an image with a sketch or an

06:28 edge map. For fine-tuning, Diffusers supports Stable Diffusion LoRA training, and the readme links a DreamBooth guide. And for running it, you can use Diffusers, ComfyUI through the extra models node, or SG Lang if you want an API server. So, you’re not locked into one script. Whatever tool you already use, there is probably a path. If you want to repeat my test, this is the code, and it’s straight from the model card. You load Stable Diffusion pipeline from Diffusers, point it at the BF16 repo, and set variant to BF16, and torch dtype to bfloat16. That variant line is the one I got wrong the first time. Then

07:03 you move the VAE and the text encoder to bfloat16 as well. Send the pipeline to CUDA, and call it with a prompt height and width of 1024, and guidance scale 4.5. I used 20 steps for this one. And if you have less than about 11 GB of free VRAM, turn on model CPU offload, and expect it to be slower. On my laptop with offload on, the Stable Diffusion 0.6b model took about 21 seconds per image against 0.38 on the A40, and part of that gap is the offload. I put my

07:34 benchmark scripts and every timing in the description, so you can compare your own card with mine. So, here’s my verdict with numbers. If you have an 8-GB card, use the 4-bit version. The readme says it runs under 8 GB, but I did not test that one, so I can’t promise the speed. If you have 12 to 24 GB, Sanas Sprint gives you a 1024 image in under half a second on a card like an A40, and the 1.6B at 20 steps is about 2 and 1/2 seconds. And if you don’t have the hardware, renting costs about a dollar for an hour and a half of testing like this. I spent about 10 cents on this whole benchmark. The

08:08 latest release is version 2.0.0 Sanas video and Sanas video and Sanas WM. So, a video review of that is next. If you’re looking for cheap and reliable GPUs, I use RunPod, and the link is in the description. So, in this video, we have seen that Sanas Sprint makes a 1024 image in 0.38 seconds on an A40, but takes more than 20 seconds on my 8-GB laptop. Go ahead and try this on your own system, and let me know your timing in the comments. I’ll see you in another one.