infosave/Lumina-Image-2.0cmf

Lumina-Image 2.0 — CMF (3.3 GB, one file, no Python)

Alpha-VLLM/Lumina-Image-2.0 packed into a single CMF file and run by a pure-Rust engine. No torch, no diffusers, no CUDA install, no C++ toolchain — one binary and one file.

512×512, 30 steps, seed 7, prompt: "a red fox sitting in snow at sunset, photorealistic, detailed fur" — rendered by the command below on a fanless MacBook Air.

Which file

Two layouts of the same weights — same 4-bit grid, same images.

file	size	notes
lumina-q4tp.cmf	3.27 GB	take this one. Needs cortiq ≥ 0.5.40
lumina-q4t.cmf	3.45 GB	the older layout, for cortiq < 0.5.40

q4tp keeps the nibbles byte-identical and stores each tile's scale as a 5-bit rung on a per-row ladder instead of a standalone f16 — the scale field was 11% of a q4t file. Rendering speed is unchanged (interleaved at 256px/8 steps on a fanless M4: 26 and 27 s against 27 and 26), and so is the image: 43.6 dB PSNR against the q4t render, 0.31% mean pixel difference.

Any existing .cmf converts in place, no checkpoint needed:

cortiq requant lumina-q4t.cmf --output lumina-q4tp.cmf --quant q4tp

What is in the file

The whole pipeline, not just the transformer: Gemma-2 text encoder + Next-DiT + FLUX VAE + the tokenizer, 888 tensors, 5.27B parameters across the three stages. The diffusers checkpoint this comes from is ~20 GB across four directories; this is 3.2 GB in one mmap-served file that checks its own integrity.

	diffusers	this file
Size	~20 GB	3.2 GB
Files	4 directories	1
Runtime deps	torch + diffusers + transformers	none

Projections are q4_tiled; modulation and embeddings stay q8, the VAE f16, norms f32.

Speed

Measured on a fanless MacBook Air (Apple M4) — 10-core CPU (4 performance + 6 efficiency), 10-core GPU, 24 GB unified memory, macOS 27. End to end: model load, prompt encode, denoise, VAE decode, file written.

	30 steps, CFG 4
512 × 512	162 s (~5.4 s/step)
256 × 256	50 s (~1.6 s/step)

Needs cortiq ≥ 0.5.36. Before it, the fused DiT paths asked a per-op probe for permission and lost the coin flip a third to two thirds of the time, which cost 7.7–9.0 s per step instead of 4.5–5.8.

Honest scope: the fused on-device DiT block is native Metal only. On Linux/Windows the engine runs the same pipeline on the CPU — correct, but several times slower. A Vulkan/DX12 DiT block is not written yet.

Run it

cargo install cortiq-cli          # pure Rust; needs >= 0.5.36
hf download infosave/Lumina-Image-2.0cmf lumina-q4t.cmf --local-dir .

CMF_GPU=1 cortiq imagine lumina-q4t.cmf \
  --prompt "a red fox sitting in snow at sunset, photorealistic, detailed fur" \
  --height 512 --width 512 --steps 30 --seed 7 --out fox.ppm

Output is P6 PPM (no image-library dependency in the engine). Convert with anything: sips -s format png fox.ppm --out fox.png on macOS, convert fox.ppm fox.png with ImageMagick, or ffmpeg -i fox.ppm fox.png.

Flags that matter: --steps (30 is the default and a good trade), --cfg (4.0 default; ≤ 1 disables classifier-free guidance and halves the work at some prompt-adherence cost), --seed, --height/--width (multiples of 16).

Reproduce the packing

cortiq imagine-pack <diffusers-root> --quant q4t --out lumina-q4t.cmf

<diffusers-root> is the Lumina-Image-2.0 checkout with tokenizer/, text_encoder/, transformer/, vae/. Takes ~9 minutes and streams shard by shard.

Fidelity

The engine mirrors the diffusers Lumina2Pipeline: the system-prompt template, Gemma hidden_states[-2] as caption features, FlowMatchEulerDiscrete with static shift 6, the model called at t = 1 − σ, CFG with per-row norm rescaling and the sign flip before the Euler step. What quantization costs has not been measured against the f32 reference on a benchmark — treat the sample above as the evidence on offer, and the exact f32 path (cortiq imagine <diffusers-dir>) as the thing to compare against if you need to know.

License

Apache-2.0, inherited from the base model. Weights © Alpha-VLLM; this repackaging only changes the storage format.

The engine, converter and format spec: https://github.com/infosave2007/cmf