Image generation model

Self-hosting Lumina: 2.6B fits a 24GB card, 8B does not

Alpha-VLLM at Shanghai AI Laboratory shipped the same brand across three genuinely different architectures — diffusion, autoregressive, and fully discrete diffusion. Here is what each one actually weighs, what it costs per image, and which card to rent.

Lumina · self-hosted

When people search "Lumina VRAM requirements" they are usually thinking of three different models without realising it. Lumina-Image 2.0 is a 2.6B Next-DiT diffusion model that generates at 1024x1024. Lumina-DiMOO is an 8B unified model built entirely on discrete diffusion, doing generation, editing and understanding in one set of weights. Lumina-mGPT 2.0 is a pure decoder-only autoregressive model that emits an image token by token. Their memory footprints differ by a full order of magnitude, so estimating hardware for "Lumina" as if it were one model will burn you.

The thing most people underestimate about Lumina-Image 2.0 is that it is not a one-checkpoint SD-style model. The official ComfyUI repack splits into three files: lumina_2_model_bf16.safetensors at 5.22GB, gemma_2_2b_fp16.safetensors at 5.23GB, and ae.safetensors at 335MB — 10.8GB together. The text encoder weighs as much as the DiT backbone. Anyone who does the 2.6B-times-two-bytes arithmetic, concludes 5GB is enough, and rents accordingly will OOM halfway through loading. Note too that the tensors in the official Hugging Face repo are typed F32, so a plain from_pretrained pull is noticeably larger on disk and egress than that bf16 repack.

What actually made Lumina popular is not the base weights but the anime fine-tunes built on them: neta-art's Neta Lumina v1.0, and duongve's NetaYume-Lumina-Image-2.0 v2 trained on top of that. Both keep the Lumina-Image 2.0 architecture and the Apache-2.0 licence, both mix Danbooru tags with natural language prompting, and Neta's own documentation puts the floor at 8GB of VRAM, ComfyUI only. The hardware table below covers reproducing that stack on a rented card.

01 —

The Lumina family as it stands, with real footprints

Parameter counts, weight sizes, resolutions and what each line is actually for — every number from the official repos

Version	Parameters	VRAM	Context	Notes
Lumina-Image 2.0	2.6B (Next-DiT)	~10.8GB in bf16: 5.22GB DiT + 5.23GB Gemma-2-2B fp16 + 335MB VAE	1024x1024	The mainline text-to-image model, Apache-2.0, accepted at ICCV 2025. Gemma-2-2B as text encoder, FLUX's 16-channel autoencoder as VAE. Exposed in diffusers as Lumina2Pipeline with defaults of 50 steps, guidance_scale 4.0 and cfg_trunc_ratio 0.25.
Lumina-DiMOO	8B (fully discrete diffusion)	38.9GB measured on a single A800; 45.9GB with ML-Cache enabled	Arbitrary and high resolution	A unified multimodal model that treats both text and images as discrete diffusion, covering text-to-image, image-to-image, editing, inpainting, extrapolation and image understanding. Took first place on the UniGenBench generation leaderboard in September 2025, now supported in both Diffusers and ComfyUI, and the most actively maintained line in the family.
Lumina-mGPT 2.0 / 2.0-Omni	7B (the HF weights page labels it 8B, BF16)	80GB native on A100; 79.2GB with speculative Jacobi; 33.8GB with speculative Jacobi plus quantization	768px text-to-image; 512px / 768px image-to-image	A decoder-only autoregressive image model trained from scratch; the Omni checkpoint adds image-pair generation, subject-driven generation, multi-turn editing, controllable generation and dense prediction. Speed is the price: 694 seconds per image on an A100, 324 with speculative Jacobi, 304 with both optimisations.
Neta Lumina v1.0	2.6B (fine-tuned from Lumina-Image 2.0)	Same class as the base model; official floor is 8GB VRAM	1024x1024, 768x1532, 968x1322 — do not go below 1024	The anime fine-tune from neta-art and by far the most-used Lumina derivative. Recommended settings are res_multistep or euler_ancestral sampling with the linear_quadratic scheduler, 30 steps, CFG 4 to 5.5, ComfyUI only. Ships both an all-in-one checkpoint and split unet / text_encoders / vae files.
NetaYume-Lumina-Image-2.0 v2 (with GGUF)	2.6B, quantised	GGUF backbone only: Q4_K_M 2.13GB / Q5_K_M 2.35GB / Q8_0 3.09GB / BF16 5.22GB	1024-class	Trained further on top of Neta Lumina, aiming at photoreal portraits as well as anime. The community shipped a full GGUF ladder down to Q2_K at 1.43GB. Critically, only the DiT backbone is quantised — Gemma-2-2B and the VAE still have to fit somewhere, so do not pick a card off the 2.13GB figure. CFG 4 to 7, 40 to 50 steps.
Lumina-Video 1.0	Multi-scale Next-DiT	No official VRAM figure published — measure it yourself	1248x704, 24fps, up to 96 frames (about 4 seconds)	The family's exploratory video line, checkpoint Alpha-VLLM/Lumina-Video-f24R960. Maintenance has been much slower than the image side since release, so treat it as a technical demo rather than a production pipeline.

02 —

Which card to rent for Lumina

Measured memory mapped honestly onto NexGPU's actual inventory and list rates

Lumina-Image 2.0 or Neta Lumina, single card, 1024x1024 at full precision
RTX 3090 24GB$0.193/GPU-hr
10.8GB of weights plus 1024-square activations leaves plenty of headroom in 24GB, and this is the cheapest 24GB card on the list — cheaper than the 16GB Tesla T4 at $0.298, so there is no reason to squeeze into less memory.
LoRA fine-tuning Lumina-Image 2.0, batch generation, or holding Neta and NetaYume side by side
RTX 4090 24GB$0.540/GPU-hr
Ada's bf16 throughput is far ahead of Ampere, which drives down the fixed cost of a 50-step image, and it absorbs gradients and optimiser state during fine-tuning; if memory gets tight, step up to the RTX A6000 48GB at $0.817/GPU-hr.
Lumina-DiMOO 8B full-capability inference, including ML-Cache
A100 PCIE 80GB$0.824/GPU-hr
The 38.9GB baseline looks like a 48GB card would do, but ML-Cache pushes it to 45.9GB with almost no headroom left; the A100 PCIE 80GB costs $0.007 more per hour than the A6000 48GB, which makes the extra 32GB effectively free.
Lumina-mGPT 2.0 7B, native 768px autoregressive generation, no quantization
A100 SXM4 80GB$1.088/GPU-hr
The official measurement is 80GB flat, and SXM4's bandwidth suits token-by-token decoding, which is memory-bound; if you accept speculative Jacobi plus quantization to get down to 33.8GB, an RTX A6000 48GB at $0.817/GPU-hr is enough.

03 —

From cold instance to first image

Four steps, covering both the ComfyUI and the diffusers route

01
Boot an instance with ComfyUI or PyTorch preinstalled
NexGPU carries over 2,000 prebuilt images including ComfyUI, PyTorch and Stable Diffusion, so there is no driver or CUDA install to do. Get in over SSH, Jupyter, the web terminal, the REST API or the CLI. First thing after boot, confirm the card and memory match what you ordered.
```
nvidia-smi --query-gpu=name,memory.total --format=csv
```
02
Pull all three weight files, not just the DiT
The Comfy-Org repack repo has the bf16 backbone, the fp16 Gemma-2-2B and the 16-channel VAE already split, ready to drop into ComfyUI's unet, text_encoders and vae folders. The upstream Alpha-VLLM repo works too, but its tensors are F32 and therefore bigger. For the anime line, swap the backbone for neta-lumina-v1.0.safetensors or NetaYume_Lumina_v2_all_in_one.safetensors — the text encoder and VAE are shared unchanged.
```
hf download Comfy-Org/Lumina_Image_2.0_Repackaged split_files/diffusion_models/lumina_2_model_bf16.safetensors --local-dir ./models
```
03
On the diffusers route, do not drop cfg_trunc_ratio
Lumina2Pipeline is in the diffusers mainline. cfg_trunc_ratio=0.25 is this model's signature parameter — classifier-free guidance only applies over the first 25 percent of the timestep schedule, and porting a sampler loop from another model without it visibly changes the output. If memory is tight, call enable_model_cpu_offload() on the pipeline to page weights out to host RAM.
```
python -c "import torch; from diffusers import Lumina2Pipeline; p=Lumina2Pipeline.from_pretrained('Alpha-VLLM/Lumina-Image-2.0', torch_dtype=torch.bfloat16).to('cuda'); p('a serene lake at dusk', height=1024, width=1024, guidance_scale=4.0, num_inference_steps=50, cfg_trunc_ratio=0.25).images[0].save('out.png')"
```
04
For editing, outpainting and understanding, switch to Lumina-DiMOO
Lumina-Image 2.0 only does text-to-image. Inpainting, extrapolation, subject-driven generation, multi-turn editing and image understanding all live in Lumina-DiMOO's single 8B model. ML-Cache exposes three knobs — cache_ratio, warmup_ratio and refresh_interval — and its speedup is strongest on image generation; understanding benefits far less because it decodes block-wise. Start this one on an 80GB card.
```
git clone https://github.com/Alpha-VLLM/Lumina-DiMOO.git && cd Lumina-DiMOO && pip install -r requirements.txt
```

What a real run actually costs

Take Lumina-DiMOO's own published A800 measurements: 58.2 seconds per image, 32.2 seconds with ML-Cache. The A800 is the same silicon as the A100, so single-card inference speed lines up with NexGPU's A100 PCIE 80GB at $0.824/GPU-hr. For 500 images: without the cache, 500 x 58.2s = 29,100 seconds = 8.083 hours, and 8.083 x 0.824 = $6.66. With ML-Cache, 500 x 32.2s = 16,100 seconds = 4.472 hours, and 4.472 x 0.824 = $3.69. That is $2.98 saved on the same 500 images, bought with memory going from 38.9GB to 45.9GB — which is exactly why the card has to be an 80GB one; a 48GB card cannot capture that saving. On the Lumina-Image 2.0 and Neta Lumina side the weights are only 10.8GB, so an RTX 3090 24GB at $0.193/GPU-hr costs 0.193 x 8 = $1.54 for an eight-hour overnight batch. Keeping the weights on persistent storage runs 10.8GB x $0.414 = $4.47 a month. Compute billing stops the second the instance stops; storage keeps billing until you destroy it. Metered per second, priced per hour, no minimum, no setup fee, no quota request.

04 —

Frequently asked questions

How much VRAM does Lumina-Image 2.0 really need? Is 24GB enough?

Comfortably, yes. In bf16 the DiT backbone is 5.22GB, the Gemma-2-2B text encoder is 5.23GB and the 16-channel VAE is 335MB — 10.8GB total, plus a few GB of activations at 1024x1024. The trap is sizing off the 2.6B parameter count alone and forgetting that the text encoder weighs as much as the backbone. On NexGPU an RTX 3090 24GB is $0.193/GPU-hr, metered per second, so a full evening of testing costs about a dollar and a half.

How are Lumina, Neta Lumina and NetaYume Lumina related?

Lumina-Image 2.0 is the base model from Alpha-VLLM at Shanghai AI Laboratory. neta-art fine-tuned it for anime to produce Neta Lumina v1.0. duongve then trained further on Neta Lumina's backbone to get NetaYume-Lumina-Image-2.0 v2, which targets photoreal portraits as well as anime. All three share an architecture, and the Gemma-2-2B text encoder and FLUX 16-channel VAE are interchangeable across them — you only swap the backbone file. To hold all three on one machine and compare, NexGPU's RTX 4090 24GB starts at $0.540/GPU-hr and compute billing stops when the instance does.

Why does enabling ML-Cache on Lumina-DiMOO increase memory use?

That is the trade the cache is designed to make. The official A800 numbers are 58.2 seconds at 38.9GB without it and 32.2 seconds at 45.9GB with it — roughly 7GB of memory bought back almost half the wall time. Which means the faster configuration is the one that no longer fits comfortably in 48GB. If you want ML-Cache, go straight to NexGPU's A100 PCIE 80GB at $0.824/GPU-hr, only $0.007 more than the A6000 48GB.

Why does Lumina-mGPT 2.0 take minutes to produce one image?

Because it is a pure decoder-only autoregressive model that emits the image one token at a time, rather than denoising in a few dozen parallel steps like a diffusion model. The official A100 figures are 694 seconds at 768px natively, 324 seconds with speculative Jacobi decoding, and 304 seconds with speculative Jacobi plus quantization — and speculative Jacobi is not recommended for image-to-image tasks. Long jobs like this are exactly what per-second billing is for: NexGPU's A100 SXM4 80GB is $1.088/GPU-hr and stops charging the moment the run finishes.

I only have 8GB of VRAM — can I run Lumina from a GGUF quant?

Neta Lumina's own documentation puts the floor at 8GB, ComfyUI only, and the community has built a full GGUF ladder: Q4_K_M at 2.13GB, Q8_0 at 3.09GB, down to Q2_K at 1.43GB. But only the DiT backbone is quantised — Gemma-2-2B and the VAE still need room, so on an 8GB card you will be offloading the text encoder to system RAM and paying for it in both speed and quality. If you want full-precision output images, NexGPU's RTX 3090 24GB at $0.193/GPU-hr is cheaper than the time you would spend fighting quantization.

What licence is Lumina under, and are there commercial gotchas?

The weights for Lumina-Image 2.0, Lumina-DiMOO, Lumina-mGPT 2.0, Neta Lumina and NetaYume are all Apache-2.0, which is clean. The components around them need a second look: the text encoder is Google's Gemma-2-2B, governed by Google's own Gemma terms rather than Apache-2.0, and pulling it from the upstream google/gemma-2-2b repo means accepting those terms on Hugging Face and using a token (the Comfy-Org repack sidesteps that step). The VAE is FLUX's 16-channel autoencoder, so confirm that layer's terms too before shipping commercially. Compliance is your call; on the compute side NexGPU spans 51 countries and regions, 1,175 verified rentable nodes and 2,498 GPUs, so whichever jurisdiction you need a machine in, it is there.

Start building on NexGPU

Enterprise R&D team or solo developer — either way, your first job can be running in minutes.