sysnote
Research

G-STAR's 2.5-second image model isn't in the release: DAGroup-PKU/G-star ships an 8B model, a 23 GB refiner and none of the speedups

The fastest image model in the G-STAR preprint (arXiv:2611.13004), GSTAR-Flash-1.7B, draws a 1024×1024 image in 2.5 seconds on one NVIDIA H200. You can't download it. The only checkpoint the authors have published, DAGroup-PKU/G-star on Hugging Face, is an 8B text-to-image model. The code in DAGroup-PKU/G-STAR on GitHub has none of the three engineering steps that took the paper's timing from 14.93 seconds to 2.50.

The paper is by Xu Huang and Ye Huang (equal contribution), project lead Xiaotong Li, corresponding author Daquan Zhou and seven co-authors. They work at Peking University and Meituan LongCat, with co-authors from SJTU, HUST, CUHK, Tsinghua and MBZUAI. Its core idea holds up on its own. The 2.5-second figure mostly reflects a tuned serving stack, and that stack isn't public. Paper

The idea: shorter sequences, more codes per token

Autoregressive image models are slow because they produce one grid position at a time. A 1024×1024 image at the common 16× downsampling is a 64×64 grid, so 4,096 sequential steps.

G-STAR uses product quantization, so each grid position carries several codebook entries instead of one. The paper's rule: if you compress each axis α times harder, give each position α² times more codes. The total number of codes stays the same and the sequence gets α² times shorter. GSTAR-Pro-8B, built on Qwen3-8B, works at 32× with 16 codes per position. GSTAR-Flash-1.7B, built on Qwen3-1.7B, reaches an "effective 64×" by packing each 2×2 block of positions into one. A 32×32 grid becomes 16×16, and each position carries 32 codes instead of 8. §4, Figure 2

The packing is exactly reversible, so the tokenizer loses nothing. The generator does pay for it, because it now has four times as many codes to predict at each position. The authors trained the same recipe on both layouts (Table 8). With packing, GenEval fell from 0.8060 to 0.7885, DPG from 82.49 to 80.44 and PRISM from 5.30 to 5.13. Appendix D

Predicting 16 or 32 codes per position adds sequential work inside each step. Table 4 compares three prediction heads at 512×512 with matched training:

Head GenEval PRISM Time in head per image
Causal (one code at a time) 0.8386 5.46 6.44 s
Parallel (all at once) 0.7800 4.72 1.77 s
Semi-autoregressive (G-STAR) 0.8253 5.46 3.41 s

The semi-autoregressive head computes features for every code in one pass. A single-layer causal transformer then lets each code depend on the ones sampled before it. It keeps nearly all of the causal head's quality at about half its cost. The released configs call it dspark.

Where the 2.5 seconds comes from

Figure 5 times GSTAR-Flash-1.7B at 1024×1024 with batch size 1 in BF16 on an H200. Each optimization is added on top of the previous one:

Step Latency
Causal head baseline 22.23 s
+ semi-AR head 14.93 s
+ each global step captured as one CUDA graph 5.85 s
+ fused sampling and normalization kernels in Triton 3.37 s
+ SGLang serving the Qwen3 backbone 2.50 s

The paper's new head accounts for 7.30 seconds, from 22.23 to 14.93. CUDA graph capture alone saves 9.08 seconds, more than the head does. The three systems optimizations together remove 12.43 of the remaining 14.93 seconds. The end-to-end 8.9× speedup is measured against the authors' own causal baseline. The abstract also claims a "20× speedup over prior discrete autoregressive models", and that rests on the quality-versus-latency plot in Figure 1(d). The paper gives no latency table for those other models. §5.3, Figure 5

None of this makes the result wrong. CUDA graphs and SGLang are fair tools, and the semi-AR head is what makes each step small enough for graph capture to pay off. Still, "2.5 seconds" describes a whole system, not the tokenizer. The protocol in Appendix C.1 leaves two small gaps. It says the decode loop "is captured as a single CUDA graph", but Figure 5 adds graph capture as a separate step. It also says run-to-run variation is reported, but no variation figures appear.

What the release actually contains

We read the Hugging Face repository (created Oct 30, last changed Oct 31) and the GitHub code (a single commit dated Nov 12):

  • One generation checkpoint, and it isn't Flash. DAGroup-PKU/G-star has four safetensors shards totalling 19.28 GB: a Qwen3-8B backbone with the DSpark head and 16 codebooks at 32× compression. The GitHub to-do list still shows "Remaining checkpoints and their matching visual refiners on Hugging Face" as open. The usage guide says the editing exports "are not published yet". README
  • Not clearly the Pro model from the paper. The release never calls this checkpoint GSTAR-Pro-8B. The model card says it "uses the pretrain prompt format, without SFT role tokens". In the paper, Pro went through pretraining, continued training and supervised fine-tuning. So the release doesn't say whether this is the checkpoint behind the paper's Table 1 scores (GenEval 0.84, Qwen-Image-Bench 50.07). Model card
  • A 23 GB refiner in the default path. refiner/model.safetensors is 22,997,084,110 bytes. The card calls it an "SR2x refiner", with its own visual encoder, codebooks, a diffusion transformer and a VAE. The documented command decodes through it. The model produces a 32×32 grid of codes for a 1024×1024 target, and the refiner then renders a 2048×2048 image in 52 steps. For a 1024 image, the card says to downscale with Lanczos. inference_config.json encodes the same setup (native_output_size: 2048, benchmark_output_size: 1024, refiner_steps: 52). Counting a separate 3.48 GB tokenizer, the published weights total 45.76 GB. inference_config.json · MANIFEST.json
  • No fast path. We searched both the Hugging Face files and a clone of the GitHub repo. Neither has CUDA graph capture, Triton kernels, torch.compile or SGLang integration. SGLang appears only in the README's acknowledgements. requirements.txt pins torch==2.6.0 and lists neither Triton nor SGLang. The paper's timing stack was PyTorch 2.9.1, CUDA 12.8 and Triton 3.5.1.
  • Different sampling settings. The latency runs use CFG 1.8, temperature 0.5 and top-k 1024. The release's "verified" settings are CFG 2.4, temperature 0.7, top-k 4096 and top-p 0.75, tested on an H100 80 GB.

The refiner raises a question the paper doesn't answer. Appendix C.1 says image-decoder time was measured separately. Figure 5 doesn't say which decoder was used. The paper shows the refiner only in reconstruction examples (Figure 6), next to a plain ViT decoder. The release makes the 52-step refiner the normal way to get an image. We couldn't tell from the published material whether the 2.5 seconds includes a refiner, uses the lighter ViT decoder, or covers the decoder at all.

We didn't run the model. Downloading 45.76 GB of weights wouldn't test the 2.5-second claim anyway, because neither the Flash checkpoint nor the fast path is public.

What you can and can't check

The scaling rule and the semi-AR head are ideas you can reproduce. The release includes training code for pretraining and SFT with both head types, and the head comparison in Table 4 comes with a full recipe. An 8B checkpoint plus training code is more than many image-generation papers publish. The latency headline is a different matter. Until GSTAR-Flash-1.7B and the CUDA graph, Triton and SGLang code are released, "2.5 seconds on an H200" is a measurement only the authors can make.

Comments

No comments yet. Be the first.

Write a comment

Comments are published after review.