VibeToken-Gen: Arbitrary Resolution Image Generation

• VibeToken-Gen is a resolution-agnostic autoregressive image generator that uses a short, class-conditioned latent sequence to enable high-resolution synthesis across arbitrary canvases.
• It decouples token count from image size by employing a dynamic 1D tokenization approach, resulting in constant autoregressive compute irrespective of output resolution.
• Empirical results on ImageNet-1k demonstrate that the XXL model generates 1024×1024 images with competitive gFID scores while maintaining efficiency compared to diffusion-based methods.

VibeToken-Gen is a class-conditioned autoregressive image generator built on VibeToken, a resolution-agnostic 1D Transformer-based image tokenizer that encodes images into a short, user-controllable sequence of discrete latent tokens. Its defining claim is that arbitrary-resolution autoregressive generation is limited less by autoregression itself than by conventional tokenizers whose sequence length grows with image size. By replacing dense 2D token grids with a short 1D latent sequence and conditioning generation explicitly on class label and target canvas, VibeToken-Gen supports arbitrary resolutions and aspect ratios without retraining. In the reported ImageNet-1k setting, the XXL model generates $1024\times1024$ images with 64 tokens, reports a constant 179G FLOPs per forward pass independent of resolution, and achieves high-resolution gFID results that the paper positions as narrowing the gap to diffusion models at scale (Patel et al., 27 Apr 2026).

1. Problem formulation and design objective

VibeToken-Gen is motivated by a structural limitation of standard autoregressive image generators. In conventional 2D VQ-style tokenization, the number of visual tokens scales with spatial resolution as

$T = (H/f)\cdot(W/f),$

so moving from $256\times256$ to $1024\times1024$ can increase token count from $256$ to $4096$ for a stride-16 tokenizer. Because transformer self-attention is stated to cost $\mathcal{O}(T^2)$ per layer during training, and autoregressive decoding with KV caching still accumulates $\mathcal{O}(T^2)$ total attention cost over a full sample, fixed-resolution AR systems such as LlamaGen become increasingly impractical at high resolution (Patel et al., 27 Apr 2026).

The system therefore reframes arbitrary-resolution generation as a tokenization problem. Instead of letting output size determine sequence length, VibeToken-Gen holds the autoregressive sequence length to a small latent budget $L$, while a separate tokenizer-decoder stack handles variable input and output canvases. This makes generation cost primarily a function of token count rather than of $(H,W)$. The tokenizer is trained to encode “any input resolutions into a dynamic, user-controllable sequence of 32–256 tokens,” and the generator later uses this property to synthesize images at arbitrary resolutions and aspect ratios (Patel et al., 27 Apr 2026).

A central implication is that token count and canvas size become separate control variables. The paper is explicit that token length governs compression level and compute budget, whereas target resolution and aspect ratio are passed through a distinct conditioning path. This separation is the core systems-level move that distinguishes VibeToken-Gen from fixed-grid AR baselines (Patel et al., 27 Apr 2026).

2. VibeToken tokenizer and dynamic latent representation

VibeToken-Gen depends on VibeToken, a 1D Transformer-based image tokenizer. Given an image $T = (H/f)\cdot(W/f),$0, the tokenizer patchifies it into $T = (H/f)\cdot(W/f),$1 patches, projects them to $T = (H/f)\cdot(W/f),$2, prepends $T = (H/f)\cdot(W/f),$3 learned latent tokens, and runs an encoder

$T = (H/f)\cdot(W/f),$4

A codebook

$T = (H/f)\cdot(W/f),$5

quantizes the latent outputs via

$T = (H/f)\cdot(W/f),$6

The decoder consumes the quantized latents together with learned masked output tokens: $T = (H/f)\cdot(W/f),$7 Only the masked positions are image prediction targets; the latent positions act as conditioning (Patel et al., 27 Apr 2026).

The tokenizer is “resolution-agnostic” in four concrete ways. First, it replaces fixed-grid positional assumptions with a dynamic grid position embedding. A learned base grid

$T = (H/f)\cdot(W/f),$8

is resized to the current patch lattice $T = (H/f)\cdot(W/f),$9 before being added to patch embeddings. Second, it introduces adaptive patch embedding: a base projection learned at $256\times256$0 is resized on the fly to support multiple patch sizes. Third, it uses an adaptive decoder resolution mechanism, first predicting an intermediate image at a fixed high patch size and then applying a learned downscaling convolution to the requested output canvas. Fourth, it supports dynamic-length tokenization by sampling $256\times256$1 over $256\times256$2, with the encoder and decoder both operating on exactly $256\times256$3 tokens and no padding (Patel et al., 27 Apr 2026).

The final tokenizer uses an MVQ variant with 8 codebooks of size 4096, giving an effective vocabulary of 32,768. Each latent token has 256 latent dimensions factorized into 8 sub-codes of 32 dimensions each. The training ingredients reported in the supplementary hyperparameter table are reconstruction weight 1, perceptual weight 1.1, discriminator weight 1, quantizer weight 1, and commitment cost 0.25, with adversarial training enabled after a discriminator start step. The tokenizer is trained on ImageNet-1k using mixed resolutions between $256\times256$4 and $256\times256$5, with 60% square samples and the remainder drawn from non-square aspect ratios $256\times256$6, patch sizes $256\times256$7, independent input and target resolutions, and latent lengths uniformly sampled from 32 to 256. The final training run lasts 600k iterations on 8 H100 GPUs, with batch size 8 per GPU, gradient accumulation 2, AdamW, cosine schedule, peak learning rate $256\times256$8, and bf16 (Patel et al., 27 Apr 2026).

Empirically, VibeToken-LL reports rFID 0.40 at $256\times256$9, 0.51 at $1024\times1024$0, 2.40 at $1024\times1024$1, and 3.60 on arbitrary-resolution stress tests, while supporting dynamic token lengths from 32 to 256. The paper emphasizes that this decouples token count from image size in a way conventional 2D tokenizers do not (Patel et al., 27 Apr 2026).

3. Generator architecture, conditioning, and training

VibeToken-Gen is a LlamaGen-style class-conditioned autoregressive model adapted to VibeToken latents. The basic factorization remains

$1024\times1024$2

with variable-length handling via an EOS token: $1024\times1024$3 Conditioning is class-conditional and resolution-aware. The paper specifies the conditioning vector as

$1024\times1024$4

where $1024\times1024$5 is the class label and $1024\times1024$6 is the target canvas. This explicit resolution conditioning is introduced because unconstrained decoding can exhibit stretching artifacts when the decoder is asked to realize shapes different from the source aspect ratio (Patel et al., 27 Apr 2026).

Architecturally, the tokenizer is fixed to VibeToken-MVQ-LL, and the generator uses a UniTok-compatible head together with a lightweight 4-layer residual transformer prediction head. This extra head is necessary because each VibeToken token consists internally of 8 MVQ sub-codes; the paper predicts those sub-codes within the output head rather than expanding the temporal sequence length by a factor of 8. The model also uses Query–Key LayerNorm, dropout 0.1, class dropout probability 0.1 for classifier-free guidance, and AdamW optimization. GPT-B at approximately 90M parameters and GPT-XXL at approximately 1.4B parameters are reported (Patel et al., 27 Apr 2026).

Training is carried out on ImageNet-1k with ten-crop augmentation. GPT-B is trained for 300 epochs and GPT-XXL for 150 epochs using AdamW with learning rate $1024\times1024$7, $1024\times1024$8, $1024\times1024$9, weight decay 0.05, and fp32; the paper states that bf16 was unstable for autoregressive training. Although the tokenizer supports $256$0, the generator is trained on $256$1, and the best generation results are reported at $256$2 (Patel et al., 27 Apr 2026).

This 64-token optimum is one of the more distinctive empirical findings. The paper repeatedly notes an asymmetry between reconstruction and generation: additional tokens improve reconstruction fidelity but do not improve, and can even worsen, generation gFID. The authors interpret later tokens as encoding high-frequency details that matter more for exact reconstruction than for the image distribution learned by the AR model. This suggests that, within the reported setup, the most generative information is concentrated in a very short latent prefix (Patel et al., 27 Apr 2026).

4. Scaling behavior, efficiency, and empirical performance

The headline systems claim is that VibeToken-Gen-XXL with $256$3 requires 179 GFLOPs per forward step for any resolution, whereas a fixed-resolution LlamaGen baseline scales to approximately 11 TFLOPs at $256$4. The paper reports this as 63.4$256$5 efficiency and characterizes the AR compute as constant with respect to image resolution because sequence length is fixed by $256$6, not by $256$7. It also clarifies that 179G is per forward pass without KV caching; total generation cost is therefore higher and scales with sequence length $256$8, but not with canvas size once $256$9 is fixed (Patel et al., 27 Apr 2026).

A wall-clock speed table provides the practical complement. End-to-end generation including tokenizer decoding is reported as 0.20 s for LlamaGen/XXL at $4096$0 and 32.79 s at $4096$1, versus 0.46 s for VibeToken-Gen/XXL at both $4096$2 and $4096$3. For tokenizer encode/decode alone, LlamaGen-Tok is reported at 0.005 s at $4096$4 and 0.082 s at $4096$5, while VibeToken-LL remains at 0.017 s at both resolutions (Patel et al., 27 Apr 2026).

At high resolution, the strongest reported result is on ImageNet $4096$6. The abstract states that VibeToken-Gen synthesizes $4096$7 images using only 64 tokens and achieves 3.94 gFID, whereas a diffusion-based state-of-the-art alternative requires 1,024 tokens and attains 5.87 gFID. The main table, however, reports 3.54 gFID for VibeToken-Gen-XXL at $4096$8, compared with 5.87 for NiT-XL. The paper itself therefore contains an internal inconsistency between 3.94 and 3.54; the table value is 3.54, and the prose elsewhere also uses 3.54 in the direct NiT comparison (Patel et al., 27 Apr 2026).

Across tested high resolutions and aspect ratios, the average gFID is reported as 23.23 for EDM2-L, 124.32 for FiT-v2-XL (highres), 6.05 for NiT-XL, 8.99 for VibeToken-Gen-B, and 5.53 for VibeToken-Gen-XXL. On fixed-resolution ImageNet comparisons, VibeToken-Gen-XXL reports FID 3.62 and IS 226.93 at $4096$9, and FID 3.60 and IS 230.33 at $\mathcal{O}(T^2)$0, both with 64 tokens. The paper explicitly notes that it can trail single-resolution specialist models such as RAR-XXL or LlamaGen-XXL on their native resolutions because training budget is shared across many resolutions and aspect ratios (Patel et al., 27 Apr 2026).

The generation ablations reinforce the preference for short latent sequences. On ImageNet $\mathcal{O}(T^2)$1, GPT-B models trained for 100 epochs report gFID 39.32 without CFG and 9.81 with CFG for 256 tokens, 37.68 and 9.02 for 128 tokens, and 33.15 and 8.42 for 64 tokens. A further comparison against LlamaGen at $\mathcal{O}(T^2)$2 shows VibeToken-Gen with 64 tokens achieving better unguided gFID than a 576-token LlamaGen baseline, although the guided score is somewhat worse in that particular small-scale setting (Patel et al., 27 Apr 2026).

5. Position within tokenization and generative modeling research

VibeToken-Gen belongs to a broader line of work that treats token design as a primary determinant of downstream generative efficiency. NativeTok argues that tokenizer quality should be judged not only by reconstruction but by whether token dependencies are aligned with downstream generative factorization; its “native visual tokenization” enforces causal dependencies during tokenization itself, improving gFID even when rFID is not best (Wu et al., 30 Jan 2026). By contrast, VibeToken-Gen does not impose causal token formation inside the tokenizer; it instead attacks the resolution problem by learning a short, resolution-agnostic 1D latent sequence (Patel et al., 27 Apr 2026).

A second comparison is to flexible-token inference in multimodal understanding. TokenFLEX addresses the mismatch created by fixed visual token budgets in vision-LLMs, using adaptive average pooling and stochastic dynamic token training over $\mathcal{O}(T^2)$3 tokens so that the same VLM can infer at multiple token counts with strong interpolation to unseen budgets such as 100 and 196 (Hu et al., 4 Apr 2025). VibeToken-Gen shares the dynamic-budget intuition, but applies it to class-conditioned image synthesis rather than VLM understanding, and combines it with an explicit decoder that can realize arbitrary target canvases (Patel et al., 27 Apr 2026).

The same token-economy logic appears in video and speech. VTok represents video as a key-frame spatial prefix plus a temporal stream of residual tokens, reducing token complexity from a product $\mathcal{O}(T^2)$4 to a sum $\mathcal{O}(T^2)$5 while improving both understanding and text-to-video generation benchmarks (Wang et al., 4 Feb 2026). TokensGen uses continuous condensed tokens for long-video generation, jointly generating all clip tokens with a T2To diffusion transformer and then rendering clips with token-conditioned short-video diffusion, thereby separating global planning from local synthesis (Ouyang et al., 21 Jul 2025). VibeVoice similarly achieves long-context speech synthesis by replacing dense discrete codec streams with a continuous speech tokenizer operating at 7.5 tokens per second and generating each next acoustic latent by next-token diffusion (Peng et al., 26 Aug 2025). Taken together, these systems suggest a wider shift toward short, structured, or condensed latent interfaces that are tuned to the generator’s statistical and computational needs rather than to a fixed pixel- or frame-grid representation.

6. Limitations, ambiguities, and conceptual context

The paper is explicit that VibeToken-Gen is a class-conditioned ImageNet-1k system, not an open-vocabulary text-to-image model. It also reports several trade-offs. As a resolution generalist, it can underperform fixed-resolution specialists on exact $\mathcal{O}(T^2)$6 or $\mathcal{O}(T^2)$7 benchmarks. Very small token budgets lose high-frequency detail, and the paper notes that later tokens primarily help reconstruction rather than synthesis. Without explicit target-resolution conditioning, decoding can produce stretching artifacts; even with conditioning, some qualitative samples show crops or truncations, which the authors attribute to randomized cropping during AR training. The work also does not present a formal failure analysis for unseen resolutions beyond the tested range (Patel et al., 27 Apr 2026).

There is also a terminological issue. The word “Vibe” in VibeToken-Gen refers to a model family name anchored in tokenization and dynamic-resolution generation, not to the conceptual meaning of “vibe” found in separate research on generative systems and human-AI collaboration. In “The Vibe-Automation of Automation,” “vibe” is defined as “high-dimensional contextual representations—vectors in latent space—that encode semantic, stylistic, and emotional regularities,” and the broader framework is about contextual coherence and operationalized tacit regularities rather than image token compression (Levin, 9 Feb 2026). In “Vibe Coding as a Reconfiguration of Intent Mediation in Software Development,” vibe coding denotes collaborative software creation through natural language dialogue, shifting intent mediation from deterministic instruction to probabilistic inference (Meske et al., 29 Jul 2025). In “Vibe AIGC,” a “Vibe” is a continuous latent state maintained through dialogue and used by a Meta Planner to synthesize hierarchical multi-agent workflows (Liu et al., 4 Feb 2026). The available evidence therefore suggests a nomenclatural convergence rather than a shared technical substrate.

Within image generation specifically, VibeToken-Gen’s lasting significance is likely to be its argument that arbitrary-resolution AR synthesis can be made practical by compressing image content into a short, user-controlled latent sequence whose semantics are learned to be resolution-agnostic. Its strongest evidence lies at high resolution, where a 64-token latent sequence is sufficient for competitive $\mathcal{O}(T^2)$8 generation under a flat AR compute profile. Its main limitation is equally clear: the approach is optimized for efficient, class-conditioned, resolution-generalist synthesis, not for the broader semantic expressivity or prompt-conditioned control associated with contemporary open-vocabulary generative systems (Patel et al., 27 Apr 2026).