Visual Tokenizers: A Comprehensive Survey

1. Introduction

The success of modern natural language processing relies on discrete token representations that enable scalable sequence modeling [1,2]. In contrast, visual data is continuous, high-dimensional, and spatially structured, which poses fundamental challenges for applying sequential modeling directly. Visual tokenizers [3,4] address this issue by transforming raw visual inputs, such as images, videos, and 3D data, into compact token sequences that can be processed by Transformers and related models. In image generation models, these tokenizers map the original image or video into a latent space, enabling generation in a lower-dimensional and more tractable representation space. In multimodal language models, tokenizers convert visual inputs into visual tokens that can be aligned and integrated with text tokens. Consequently, visual tokenization has become a foundational component of modern computer vision and multimodal systems.

Research on visual tokenization has evolved through several distinct stages. Early works [5,6,7,8] were typically driven by specific tasks and domains. On one hand, high-level tokenizers [5,8] are designed to extract semantically meaningful representations for visual recognition, retrieval, and dense prediction. On the other hand, low-level tokenizers [6,7] focus on compressing visual inputs for reconstruction and generation, prioritizing pixel-level fidelity through continuous or discrete latent representations. Historically, these two lines of research developed largely independently, following different objectives, architectures, and evaluation criteria.

The recent emergence of Large Language Models (LLMs) has significantly reshaped the role of visual tokenizers. Multimodal Large Language Models (MLLMs) leverage the strong capabilities of foundation LLMs, enabling a single model to handle multiple tasks, including both high-level understanding and low-level generation. This paradigm requires visual tokenizers to provide representations that are suitable for both types of tasks. Although some approaches [9,10,11] employ two separate tokenizers to obtain high-level and low-level features, a unified representation is ultimately desirable. Unified representations play a critical role in downstream training and facilitate effective interaction among different tasks [12,13]. Consequently, research on unified tokenizers has emerged rapidly in recent years.

Despite this rapid progress, the literature on visual tokenization remains fragmented. Existing methods differ substantially in architectural design, token representation constraints, training objectives, and scaling behaviors. Moreover, the term “visual tokenizer” is often used interchangeably with encoders, autoencoders, or representation learners. This inconsistency obscures the common structure underlying these approaches. The lack of a unified taxonomy and systematic comparison makes it difficult to understand design trade-offs, identify common patterns, or assess how recent unified methods relate to earlier task-specific tokenizers. Although some recent works summarize discrete tokenizers, these studies primarily focus on methods represented by VQ-VAE [7], while largely overlooking continuous tokenizers used for understanding [5] and generation tasks [6]. In this work, we also summarize unified tokenizers [12,14,15], providing insights that may facilitate the development of future unified models [11,16,17].

This work aims to provide a coherent and comprehensive overview of visual tokenizers. We first formalize the concept of visual tokenization and break down tokenizers into three core components: an encoder that extracts visual features, a bottleneck constraint mechanism that shapes the token representation, and a decoder that reconstructs or supervises visual content. And then we summarize the development of task-specific tokenizers. We categorize the techniques that enhance specific task-required abilities, distinguishing between high-level and low-level tokenizers. High-level tokenizers focus on training strategies and data scaling to enhance the semantic richness of token representations. Low-level tokenizers, on the other hand, focus on pixel reconstruction and compression. We also provide a summary of representative tokenizers’ performance on well-known benchmarks to facilitate horizontal comparisons.

Building on the need to support both high-level semantics and low-level visual details, we further discuss recent advances in unified tokenizers [12,13,14,15]. These methods aim to tokenize semantic abstractions and fine-grained visual information within a single, shared feature space. We categorize existing approaches primarily by architectural design, and broadly group unified tokenizers into single-encoder [12] and dual-encoder paradigms [18]. For single-encoder designs [12,15,19,20,21], the central research challenge is how to obtain semantically rich representations while retaining sufficient visual fidelity. Prior work can be further organized into two lines: (i) enhancing semantics, which improves semantic content through tailored objectives, training strategies, or scaling; and (ii) preserving semantics, which leverages pretrained vision foundation models to inject or maintain strong semantic priors in the token space. In dual-encoder designs [13,14,18,22,23], the primary focus is on how to fuse complementary features from two encoders. Based on encoder organization, we further divide these methods into parallel and cascade architectures, depending on whether the two feature streams are integrated symmetrically or sequentially. Additionally, we summarize the performance of unified tokenizers [13,15,17] on downstream understanding and generation tasks, and compare them against (1) single task-specific tokenizers [24,25,26,27], and (2) unified systems that rely on separate task-specific tokenizers for different objectives [9,10,11].

Finally, we discuss several open challenges and future directions for visual tokenization. In particular, we examine the trade-off between semantic density and reconstruction quality, the efficient scaling of token vocabularies, and extensions to video and 3D modalities. We also discuss the evolving role of visual tokens in next-generation multimodal systems. By organizing this rapidly growing field within a unified framework, this work aims to serve as a useful reference for researchers and practitioners in computer vision and multimodal learning.

Figure 1. We categorize visual tokenizers by downstream usage into task-specific and unified tokenizers. Task-specific tokenizers target high-level tasks (e.g., classification, dense prediction) or low-level tasks (e.g., reconstruction, dehazing). Unified tokenizers, typically designed for multimodal LLMs, support both within a single representation. Architecturally, we group them into two families and distinguish them by how they capture semantics and fine-grained details.

Figure 1. We categorize visual tokenizers by downstream usage into task-specific and unified tokenizers. Task-specific tokenizers target high-level tasks (e.g., classification, dense prediction) or low-level tasks (e.g., reconstruction, dehazing). Unified tokenizers, typically designed for multimodal LLMs, support both within a single representation. Architecturally, we group them into two families and distinguish them by how they capture semantics and fine-grained details.

2. Definition and Scope

A central lesson from large language models [1,28] is that sequence-to-sequence modeling [29] provides a universal computational paradigm. Transformers show that, with suitable tokenization, a single model class can support representation learning [8], reasoning [30], and generation [31] across tasks. This insight has influenced the design of visual representations. In this context, tokenization should be distinguished from classical feature extraction. A feature extractor (e.g., a convolutional backbone [32]) typically produces a structured feature field that is dense, grid-aligned, and closely coupled to the input domain. In contrast, tokenization [33] is a structural transformation that converts raw signals into discrete or semi-discrete units processed sequentially by a Transformer [29]. Conceptually, tokenization serves two primary roles:

• Sequentialization: imposing an ordering, indexing, or traversal over the input domain.
• Transformation: mapping raw inputs into latent representations suitable for attention-based processing.

While these roles are often intertwined in practice, distinguishing them clarifies the assumptions underlying a given visual tokenizer. This perspective raises a fundamental question:

What entities are treated as tokens, and what structural or group actions do these tokens admit?

Different answers lead to different tokenization strategies, even when the downstream architecture remains unchanged. Visual tokenizers can be broadly characterized along two axes:

1.

Input primitives: what constitutes a token (e.g., pixels, patches, points, voxels, simplices, or feature groups).

2.

Sequentialization mechanism: how these primitives are ordered or indexed (e.g., grid order, positional encodings, curve traversal, or set-to-sequence projections).

A visual tokenizer maps a visual signal into a set of tokens together with an indexing structure that enables Transformer-based processing. Formally, given a visual input $\mathbf{x}\in {\mathbb{R}}^{T\times H\times W\times 3}$, where T denotes the temporal dimension and $H,W$ denote the spatial dimensions (with $T=1$ corresponding to a single image), a visual tokenizer defines a transformation

$$f_{\theta }:\mathbf{x}\mapsto \mathbf{z},\mathbf{z}\in {\mathbb{R}}^{L\times D},$$

where L denotes the number of tokens and D the token dimension. In the discrete case, one may further have $\mathbf{z}\in {\mathbb{N}}^L$, corresponding to a sequence of codebook indices or symbolic token identities. Under this formulation, a tokenizer is defined not only by how it transforms raw visual inputs into latent units, but also by the choice of underlying primitives and the mechanism used to organize them into a sequence or indexable set. The resulting token representation $\mathbf{z}$ may therefore originate from pixels, patches, points, voxels, simplices, or higher-level feature groups, together with an ordering, positional scheme, or set-to-sequence projection that governs how attention operates over them.

2.1. Architecture

As shown in Figure 2. In numerous learned instantiations, this mapping is realized through an encoder, combined with a bottleneck, and paired with a decoder for different training supervision.

2.1.1. Encoder

1) Images. Images reside on a regular two-dimensional lattice, which makes tokenization comparatively straightforward. The dominant approach is patchification, where an image is partitioned into fixed-size patches and each patch is treated as a token. Sequentialization is achieved through positional encodings, including absolute embeddings, 2D sinusoidal encodings, or relative schemes such as rotary positional embeddings (RoPE).

From this perspective, convolutional neural networks can be interpreted as a special case of tokenization: local, translation-equivariant filters transform the image while the grid structure implicitly provides positional indexing. Vision Transformers make this separation explicit by projecting patches into a latent space, adding positional encodings, and applying global attention.

2) Video. Video extends image tokenization along the temporal dimension [34,35]. Spatial patches are extracted from each frame and stacked across time, producing tokens indexed by $(x,y,t)$. Positional encodings capture both spatial and temporal structure, often through factorized or hierarchical designs. Despite the increased dimensionality, video still benefits from the rasterized grid, which provides a natural traversal of the signal domain.

3) 3D Data. Three-dimensional data departs from this setting. Unlike images or videos, 3D data does not possess a natural uniform grid. The ambient space is large, while meaningful information is typically sparse and irregularly distributed, as observed in point clouds, surfaces, or volumetric representations.

Three-dimensional representation learning has followed two primary paradigms. Geometric (primitive-based) modeling treats primitives such as points as tokens and processes them using permutation-invariant or equivariant encoders (e.g., PointNet-style models). Voxelization-based modeling discretizes space into a 3D grid, enabling 3D CNNs or sparse convolutions, albeit with memory and resolution trade-offs.

With the adoption of Transformers, recent approaches increasingly emphasize explicit sequence-based tokenization of 3D data. Examples include space traversal via one-dimensional curves, direct traversal of simplicial or mesh structures, and feature-set or set-to-sequence representations. A key distinction from image and video models is that 3D encoders typically require an explicit compression stage. Exhaustively traversing the ambient 3D space using $(x,y,z)$ indices is computationally infeasible. Instead, redundancy and sparsity must be exploited to discard or aggregate information before applying a Transformer. This requirement reflects the mismatch between high-dimensional ambient spaces and the low-dimensional supports on which meaningful 3D signals often reside. Unlike grid-based modalities, there is no canonical one-dimensional traversal of 3D data. Any sequentialization therefore imposes additional structure and inductive bias, implicitly defining notions of locality, equivalence, and invariance. Consequently, different tokenization strategies correspond to different structural hypotheses about the data.

Although many of these techniques were originally developed for 3D shape modeling, the principles extend beyond geometric data. Any modality with high ambient dimensionality and sparsely distributed informative signals faces similar challenges. In such settings, tokenization is not merely an implementation detail but a central modeling decision that determines what structure is preserved, compressed, or treated as equivalent.

Visual tokenization thus reflects a shift from dense, domain-specific feature fields toward structured sequences of interacting units. Inspired by large language models, this paradigm elevates sequentialization and transformation to first-class design choices. While images and videos admit relatively canonical tokenizations due to their grid structure, 3D data highlights the deeper challenges—and opportunities—of tokenization in sparse, irregular, high-dimensional domains. In this sense, a visual tokenizer encodes an explicit structural hypothesis about perception itself.

Overall, visual tokenization shifts representation learning from dense, domain-specific feature fields toward structured collections of interacting units. For images and video, regular grids provide relatively canonical tokenization schemes. In contrast, for 3D data, token formation and serialization themselves become central modeling choices.

2.1.2. Bottleneck

Beyond token formation, a visual tokenizer is also defined by the bottleneck imposed on its token representation. This bottleneck determines which information is preserved, compressed, discarded, or aligned, and thus shapes the resulting token space. Depending on the model, the bottleneck may arise from architectural compression, continuous regularization, discrete quantization, or semantic supervision.

1) Architectural bottleneck. In many encoders, the bottleneck arises from the architecture through downsampling, pooling, strided convolutions, or hierarchical aggregation. Backbones such as ResNets [8] follow this design: the visual signal is progressively compressed into lower-resolution feature maps that can be viewed as continuous visual tokens. Although no explicit latent regularization is imposed, the architecture constrains the representation by limiting spatial resolution and promoting abstraction.

2) Continuous bottleneck. A stronger bottleneck can be imposed by explicitly regularizing the latent space. In probabilistic models such as Variational Autoencoders (VAEs) [6], the latent variable is modeled as a continuous distribution $p(\mathbf{z}\mid \mathbf{x})$, typically parameterized by mean $\mu$ and variance ${\sigma }^2$. Sampling is made differentiable via the reparameterization trick,

$$\mathbf{z}=\mu +\sigma \odot ϵ,ϵ\sim \mathcal{N}(0,\mathbf{I}).$$

This encourages a smooth and structured latent space suitable for interpolation and generative modeling, though it may reduce reconstruction fidelity.

3) Discrete bottleneck. In discrete tokenizers [7], the encoder output $\widehat{\mathbf{z}}$ is mapped to the nearest entry in a learnable codebook $\mathcal{C}={\left\{{\mathbf{e}}_k\right\}}_{k=1}^K$:

$${\mathbf{z}}_q={\mathbf{e}}_k,k=arg\underset{j}{min}{\parallel \widehat{\mathbf{z}}-{\mathbf{e}}_j\parallel }_2.$$

This quantization converts continuous features into indexable symbols, producing token sequences compatible with autoregressive or masked token modeling.

4) Semantic bottleneck. In vision-language models such as CLIP [33] and SigLIP [36], the bottleneck arises from semantic alignment rather than reconstruction or discretization. The encoder retains information predictive of language supervision while discarding nuisance variation, shaping the representation toward semantic alignment.

2.1.3. Decoder

The decoder maps token representations to the target space defined by the training objective. This space may correspond to the input domain, a task-specific label space, or a shared semantic embedding space. Thus, the decoder determines how token representations are read out and what information they preserve.

In reconstruction-based tokenizers, such as VAEs [6] and related compression models [37], the decoder $\mathcal{D}(·)$ reconstructs the input $\mathbf{x}$ from $\mathbf{z}$, or its quantized form ${\mathbf{z}}_q$, such that $\widehat{\mathbf{x}}=\mathcal{D}\left(\mathbf{z}\right)\approx \mathbf{x}$. These decoders are typically implemented with upsampling layers, transposed convolutions, or patch-based reconstruction modules, and are evaluated by PSNR, SSIM, and rFID.

In discriminative encoders such as ResNet-style [8] visual backbones, no explicit reconstruction decoder is required; the representation is instead read out through task-specific prediction heads. In contrastive vision-language models such as CLIP [33] and SigLIP [36], the decoder takes the form of a projection head into a shared semantic space aligned with text. Thus, while reconstruction-based models decode signals, discriminative and contrastive tokenizers decode predictions or semantic correspondences. We compare these tokenizers in Section 5.

3. Task Specific Visual Tokenizers

Prior to Large Language Models (LLMs) and AI-Generated Content (AIGC), visual tokenizers were mainly studied in visual representation learning and generation tasks. Tokenizer design was largely driven by task-specific supervision rather than a unified multimodal perspective. In this section, we review representative pre-LLM methods and organize them by the information encoded in the tokens: high-level semantic tokens and low-level reconstruction tokens. We focus on the evolution of technical approaches and design motivations.

3.1. High-Level Tokenizers

High-level tokenizers emphasize semantic abstraction rather than pixel-level fidelity. Before LLM, these works serve as backbone networks. This section reviews methods that strengthen semantic representations through training strategies and data scaling.

3.1.1. Training Strategy

Summary. Training strategies differ by the source of supervision: (1) Supervised learning uses human annotations, ranging from clean curated labels (strong) to scalable but noisy web image–text pairs (weak). (2) Self-supervised learning replaces external labels with pretext signals mined from the data to learn transferable semantics. (3) Distillation uses a strong teacher to supervise a lightweight student tokenizer by mimicking its outputs or features.

Supervised Learning. 1) Strong Supervision: Strong supervision typically refers to training on large-scale datasets with full ground-truth annotations, especially for image classification. Progress under this paradigm largely follows the evolution of deep architectures. AlexNet [38] first demonstrates GPU-trained CNNs on ImageNet. VGG [39] shows that deeper networks with small $3\times 3$ convolutions improve performance. ResNet [8] introduces residual connections, enabling very deep networks. More recently, Vision Transformer (ViT) [4] treats images as patch sequences and shows that Transformers scale effectively. To incorporate useful inductive biases, Swin Transformer [40] proposes a hierarchical shifted-window design. Finally, ConvNeXt [41] revisits CNNs with ViT-inspired designs (e.g., larger kernels and LayerNorm), showing modernized CNNs remain competitive with Transformers.

2) Weak Supervision: Since dense human labels are costly, recent work trains on large-scale noisy web image–text pairs. CLIP [5] and ALIGN [42] show that contrastive learning on such data yields highly transferable representations. LiT [43] improves efficiency by freezing a strong image encoder while tuning the text encoder. SigLIP [44] replaces softmax with a pairwise sigmoid loss, enabling more stable large-scale training. SigLIP-2 [36] further improves multilingual and dense features via caption-based pretraining and self-distillation, while the Perception Encoder [45] shows that dense semantics often emerge in intermediate layers.

Strong supervision provides clean signals and reliable evaluation but is limited by annotation cost and fixed label spaces. Weak supervision scales cheaply and supports open-vocabulary transfer, though it suffers from noisy captions and dataset biases, making dense or fine-grained performance dependent on data curation and training recipes.

Self-Supervised Learning. While supervised learning scales with web text, it still depends on linguistic signals that may overlook fine-grained visual structure. Self-supervised learning (SSL) instead learns directly from visual data.

1) Predictive-Based: Predictive SSL mirrors masked language modeling [46] by predicting hidden visual content. BEiT [47] adapts BERT-style masking to images using discrete VAE tokens. MAE [48] simplifies this by masking many patches and reconstructing pixels, enabling scalable representation learning. I-JEPA [49] predicts missing regions in latent space rather than pixels. EVA [50] further connects predictive SSL with vision-language pretraining. TIPS [51] combines image–text contrastive learning with masked modeling to improve spatial awareness in frozen vision-language models.

2) Discriminative-Based: Discriminative SSL learns representations by distinguishing views of the same image. MoCo [52,53] uses a momentum encoder and queue for contrastive learning, while SimCLR [54] shows large batches and strong augmentations suffice without memory banks. BYOL [55] removes negatives using asymmetric networks with a predictor. DINO [56] extends this idea via self-distillation, revealing segmentation cues in ViTs. DINOv2 [57] scales this approach with curated data for general-purpose features. DINOv3 [58] further improves dense features with large-scale SSL and Gram Anchoring.

Predictive SSL typically learns spatially detailed features but may emphasize reconstruction and require decoders, whereas discriminative SSL yields more invariant semantics but relies heavily on training design.

Distillation. Beyond training from scratch, high-level tokenizers are often improved via distillation. Two directions dominate: (1) Efficiency-driven distillation, compressing foundation models into lightweight students. (2) Capability-driven agglomeration, consolidating multiple teachers into a single tokenizer.

1) Efficient Models: Knowledge distillation (KD) [59] transfers representations from large teachers to compact models. DeiT [60] introduces a distillation token for efficient transformers. TinyMIM [61] and DMAE [62] transfer token-level relations for dense understanding. EdgeSAM [63] distills heavy segmentation backbones while preserving interactive performance. DINOv3 [58] further improves dense features using Gram-based teachers and multi-student distillation.

2) Agglomerative Strategies: Different teachers provide complementary capabilities. CLIP-like models capture global semantics, while DINO/SAM provide dense correspondence and structure. Agglomerative distillation combines these strengths into a single tokenizer. AM-RADIO [64] distills heterogeneous teachers (CLIP, DINO, SAM) into one model. RADIOv2.5 [65] addresses resolution shifts, teacher imbalance, and token-budget limits through multi-resolution training and improved loss balancing. C-RADIOv3 [66] further improves robustness via stronger distribution control. C-RADIOv4 [67] upgrades the teacher suite (SigLIP2/DINOv3/SAM3) and strengthens any-resolution modeling. Related work includes SAM-CLIP [68], which merges semantic and spatial models via replay distillation, and Open-Vocabulary SAM [69], which unifies segmentation with large-vocabulary recognition. Beyond perception, Theia [70] distills multiple VFMs into compact representations for robot learning.

3.1.2. Data Scaling

Data scaling complements architectural advances: larger and more diverse corpora improve coverage and robustness, while dataset quality and composition determine the semantics encoded in tokens. We summarize progress from two perspectives—data sources and data curation.

Data Sources. 1) Real Datasets: Real-world datasets have evolved from curated labeled collections to web-scale image–text corpora, where scale and filtering jointly determine representation quality. Early work relies on benchmarks such as ImageNet [71]. JFT-300M [72] shows that data scale can outweigh architectural changes when paired with effective curation. With weak supervision, open datasets such as LAION-5B [73] popularize CLIP-based filtering for quality control. DataComp-1B [74] formalizes dataset construction as an optimization problem and benchmarks curation strategies under fixed compute. At larger scales, WebLI-100B [75] extends multimodal pretraining to 100B examples. Overall, real datasets have progressed in both scale (up to 100B) and quality through improved filtering and curation.

2) Synthetic Data: Recent work explores synthetic data as a scalable alternative. StableRep [76] shows that diffusion models can generate diverse multi-view images for contrastive pretraining. CapsFusion [77] improves supervision by rewriting captions with LLMs to enrich semantic content. SynCLR [78] studies fully synthetic pipelines that generate both images and captions at scale, demonstrating that synthetic-only corpora can approach real-data performance. These results suggest synthetic data is not merely augmentation but a complementary route to scalable representation learning.

Data Curation. 1) Clustering and Balancing: At web scale, structuring data becomes critical. Naive sampling over web crawls over-represents common content while under-sampling rare concepts. Clustering-based curation groups examples into semantic buckets (often using CLIP embeddings) and balances sampling across clusters. MetaCLIP [79] shows that metadata clustering improves coverage and reduces bias without dense annotation. Similar clustering-based selection also improves self-supervised learning under fixed compute [80].

2) Sampling Strategies: Beyond filtering, batch sampling also affects optimization. The two-set training strategy [81] mixes a frequently repeated subset with a stream of new samples to accelerate learning. In vision, DINOv3 [58] adopts mixed sampling by combining homogeneous ImageNet-1K batches for stable features with heterogeneous batches from larger datasets, improving stability while preserving generalization.

3.2. Low-Level Tokenizers

Unlike semantic tokenization, which extracts high-level representations, low-level tokenization compresses visual signals into compact features while preserving details for reconstruction. Although some low-level tokenizers [6,82] are generative models, we focus here on tokenization rather than generation performance. We organize this section along three dimensions: (1) reconstruction fidelity, (2) representation and compression efficiency, and (3) representation disentanglement.

3.2.1. Maximizing Reconstruction Fidelity of Continuous Low-Level Tokenizers

Standard autoencoders can achieve low reconstruction error, but their unconstrained feature spaces often exhibit high variance and discontinuities, making them unsuitable for tokenization. Variational Autoencoders (VAEs) [6] address this by introducing Kullback–Leibler (KL) regularization to enforce a smooth latent manifold:

$${\mathcal{L}}_{\mathrm{VAE}}=\underset{{\mathcal{L}}_{\mathrm{rec}}}{\underbrace{{\mathbb{E}}_{q_{\varphi }\left(z\right|x)}[-log{p}_{\theta }\left(x\right|z)]}}+\underset{{\mathcal{L}}_{\mathrm{reg}}}{\underbrace{\beta D_{\mathrm{KL}}\left(q_{\varphi }\left(z\right|x)\Vert p\left(z\right)\right)}},$$

(1)

where $q_{\varphi }$ and $p_{\theta }$ denote the encoder and decoder. ${\mathcal{L}}_{\mathrm{rec}}$ (typically MSE) preserves data fidelity, while ${\mathcal{L}}_{\mathrm{reg}}$ regularizes the posterior toward the prior $p\left(z\right)$.

Despite this regularization, vanilla VAEs still exhibit lower reconstruction fidelity than standard autoencoders due to several limitations. First, posterior collapse occurs when $q_{\varphi }\left(z\right|x)$ degenerates to the prior $p\left(z\right)$ (e.g., $\mathcal{N}(0,I)$), weakening the dependence between latent codes and inputs and causing loss of fine visual details. Second, the simple Gaussian prior forces complex visual distributions into an isotropic form, often producing overly smooth reconstructions with blurred textures. Third, the information bottleneck arises because reconstruction depends on low-dimensional latent codes, limiting achievable fidelity. Finally, simple pixel-wise losses (e.g., MSE) poorly capture perceptual similarity and local structure, further degrading reconstruction quality.

Addressing Posterior Collapse. Posterior collapse occurs when strong KL regularization forces $q_{\varphi }\left(z\right|x)$ to match the prior, causing the decoder to ignore latent codes.

Wasserstein Autoencoders (WAE) [83] mitigate this by matching the aggregated posterior $q_{\varphi }\left(z\right)={\mathbb{E}}_{p_{\mathrm{data}}\left(x\right)}\left[q_{\varphi }\left(z\right|x)\right]$ to the prior:

$${\mathcal{L}}_{\mathrm{WAE}}=\underset{{\mathcal{L}}_{\mathrm{rec}}}{\underbrace{{\mathbb{E}}_{p_{\mathrm{data}}\left(x\right)}{\mathbb{E}}_{q_{\varphi }\left(z\right|x)}\left[c(x,p_{\theta }\left(z\right))\right]}}+\underset{{\mathcal{L}}_{\mathrm{reg}}}{\underbrace{\beta D_Z(q_{\varphi }\left(z\right),p\left(z\right))}}.$$

(2)

This relaxes per-sample constraints and better preserves high-frequency details. Sliced-WAE [84] further improves stability by projecting latent distributions into 1D and computing Wasserstein distance in closed form.

Another strategy weakens KL regularization directly. Latent Diffusion Models (LDM) [31] assign an extremely small KL weight (e.g., $\beta ={10}^{-6}$), preventing over-regularization while maintaining high reconstruction quality.

A more radical solution is discrete tokenization. VQ-VAE [7] replaces the Gaussian prior with a learnable codebook $\mathcal{C}={\left\{e_k\right\}}_{k=1}^K$:

$$z_q\left(x\right)=e_k,k=arg\underset{j}{min}{\parallel z_e\left(x\right)-e_j\parallel }_2.$$

(3)

This discrete bottleneck eliminates KL collapse and enables high-fidelity modeling with autoregressive or diffusion priors [85,86,87].

Enriching Prior Distributions. The Gaussian prior often poorly matches the complex manifold of natural images. Several approaches therefore adopt more expressive priors.

Adversarial Autoencoders (AAE) [82,88] replace KL regularization with adversarial matching between the aggregated posterior and prior:

$$\underset{G}{min}\underset{D}{max}{\mathbb{E}}_{z\sim p\left(z\right)}[logD\left(z\right)]+{\mathbb{E}}_{x\sim p_{\mathrm{data}}}[log(1-D\left(G\left(x\right)\right))].$$

(4)

IntroVAE [89] introduces self-adversarial training where the encoder acts as the discriminator, while Soft-IntroVAE [90] stabilizes training via ELBO-based energy functions.

Other work adopts explicit learnable priors. GMVAE [91] models $p\left(z\right)$ as a Gaussian mixture:

$$p\left(z\right)={\displaystyle \sum _{k=1}^K}{\pi }_k\mathcal{N}\left(z\right|{\mu }_k,{\Sigma }_k).$$

(5)

VampPrior [92] defines the prior as a mixture of variational posteriors conditioned on pseudo-inputs.

Two-stage methods instead decouple representation learning and prior estimation. VAIOP [93] learns an implicit optimal prior after encoder training, while contrastive priors [94] structure latent spaces via similarity learning. DiTo [95] replaces the prior with diffusion conditioning tokens for reconstruction. UNITE [96] unifies image tokenization and latent denoising through a shared Generative Encoder, enabling end-to-end single-stage training of latent diffusion models without a separately trained tokenizer.

Addressing Information Bottleneck. Single-layer VAEs impose a severe information bottleneck. Hierarchical VAEs distribute information across multiple latent scales.

LVAE [97] introduces bottom-up and top-down inference paths with layer-wise KL terms:

$$\begin{array}{cc}\hfill {\mathcal{L}}_{\mathrm{LVAE}}& ={\mathbb{E}}_{q_{\varphi }\left(\mathbf{z}\right|x)}[log{p}_{\theta }\left(x\right|\mathbf{z})]\hfill \\ \hfill & -{\displaystyle \sum _{l=1}^L}{D}_{\mathrm{KL}}\left(q_{\varphi }\left(z_l\right|z_{l-1},x)\Vert p_{\theta }\left(z_l\right|z_{l+1})\right).\hfill \end{array}$$

(6)

BIVA [98] strengthens bidirectional inference, while NVAE [99] scales hierarchical depth with residual parameterization. VDVAE [100] pushes this further with up to 78 stochastic layers.

Another direction expands the encoder’s receptive field. Latent Diffusion Models [31] add self-attention to convolutional encoders to capture global context and improve reconstruction.

Optimization Strategy. To overcome the limitations of pixel-wise reconstruction objectives, such as mean squared error (MSE), which often lead to over-smoothed and blurry outputs due to global averaging. VQGAN [85] pioneered a more powerful paradigm by introducing patch-based adversarial supervision and perceptual losses (e.g., LPIPS) into the vector-quantization framework. This design constrains reconstructed tokens to lie closer to the manifold of natural images, thereby preserving sharper structures and richer high-frequency textures.

Building on this line of work, SD-VAE [31] further improves reconstruction quality by incorporating attention blocks to capture long-range dependencies across spatial tokens. In addition, it leverages a series of practical engineering techniques to substantially enhance the reconstruction capability of the VAE, yielding significantly more faithful and visually appealing outputs. Subsequent work [101] further improves reconstruction quality by enriching perceptual supervision. In addition to conventional perceptual losses, they explicitly align the ConvNeXt [41] features of the input image x and the reconstructed image $\widehat{x}$, which can be formulated as

$${\mathcal{L}}_{\mathrm{perc}}^{\mathrm{ConvNeXt}}=\sum _l{∥{\varphi }_l^{\mathrm{ConvNeXt}}\left(x\right)-{\varphi }_l^{\mathrm{ConvNeXt}}\left(\widehat{x}\right)∥}_2^2,$$

(7)

where ${\varphi }_l^{\mathrm{ConvNeXt}}(·)$ denotes the feature representation at the l-th layer of a pretrained ConvNeXt model. Compared with pixel-space supervision, such feature-level alignment provides a stronger semantic and structural constraint, leading to more faithful reconstructions.

Meanwhile, some studies [19,102] replace or initialize the discriminator with stronger foundation models [57], endowing the adversarial branch with a more powerful prior over natural image statistics. Denoting such a discriminator by $D_{\mathrm{FM}}$, the adversarial objective can be written as

$${\mathcal{L}}_{\mathrm{adv}}={\mathbb{E}}_x\left[log{D}_{\mathrm{FM}}\left(x\right)\right]+{\mathbb{E}}_{\widehat{x}}\left[log\left(1-D_{\mathrm{FM}}\left(\widehat{x}\right)\right)\right].$$

(8)

By leveraging the representational strength of pretrained foundation models, these approaches provide more informative supervision signals and further enhance perceptual fidelity and texture realism in the reconstructed images.

3.2.2. Maximizing Reconstruction Fidelity of Discrete Low-Level Tokenizers

Unlike continuous low-level tokenizers, discrete low-level tokenizers use quantization to represent visual data with a finite set of code entries. They were originally introduced to address the posterior collapse problem [7]. However, because discrete token representations are highly compatible with LLMs [1], discrete tokenizers have received broad attention, especially in terms of improving reconstruction quality.

As mentioned above, discrete tokenizers represent visual data using a limited number of code entries. Therefore, preserving fine-grained details usually requires a sufficiently large codebook [103]. Below, we summarize how earlier studies have effectively scaled up the codebook size.

Scaling the Codebook of Discrete Tokenizers. For discrete tokenizers, ]the discretization paradigm was originally introduced to resolve the posterior collapse issue inherent in continuous VAEs. However, this introduces a new challenge: since the codebook is finite, the encoder is compelled to map diverse visual data to a limited set of discrete entries. This quantization process inevitably incurs information loss, manifesting as quantization error. A straightforward strategy to mitigate this loss is to increase the codebook size K. However, naively expanding K often leads to “codebook collapse,” a phenomenon where the model utilizes only a small fraction of the available codes, rendering the majority of the codebook redundant.

1) Optimization Strategies. To maintain high utilization in large codebooks, VQ-VAE [7] employs Exponential Moving Average (EMA) updates to smooth the embedding learning. More aggressively, VQGAN-LC [103] introduces a frequency-based initialization strategy to revive “dead codes,” enabling codebooks to scale effectively to 100,000 entries. SQ-VAE [104] replaces deterministic quantization with stochastic sampling, thereby encouraging the exploration of the codebook space. IBQ [105] facilitates gradient flow into the index selection process, correcting the mismatch typically caused by straight-through estimators. Furthermore, FVQ [106] proposes VQBridge, an efficient projector module inserted before the quantization step. Crucially, VQBridge ensures that even unused code entries receive gradient updates within the projection space, thereby achieving stable and effective codebook training. By combining VQBridge with a learning rate annealing schedule, FVQ achieves full (100%) codebook utilization across diverse configurations.

2) Addressing Quantization Cost. As the codebook size K increases, the quantization process, which necessitates calculating the distance between the encoder output and every codebook entry, incurs prohibitive computational and memory costs scaling linearly with $O\left(K\right)$. To circumvent this bottleneck, recent advancements [107,108,109] have proposed implicit codebook quantization methods that eliminate the need for explicit nearest-neighbor search.

Finite Scalar Quantization (FSQ) projects continuous representations onto a fixed, pre-defined integer grid, thereby removing the requirement for storing and learning explicit embedding vectors.

Lookup-free Quantization (LFQ), notably utilized in MAGVIT-v2 [107], leverages a binary latent token space where code indices are directly derived from the sign bits of each latent token embedding $z\in {\mathbb{R}}^d$ components:

$$k={\displaystyle \sum _{i=0}^{d-1}}\mathbb{I}(z_i>0)·2^i.$$

(9)

where $z_i$ is the i-th component of z. This mechanism allows the effective vocabulary size to scale exponentially with the latent token dimension (e.g., $2^{18}$ for $d=18$) while incurring zero storage and computation cost for the codebook. To encourage uniform usage of the binary codes, MAGVIT-v2 introduces an entropy penalty on the code distribution:

$${\mathcal{L}}_{\mathrm{entropy}}={\mathbb{E}}_x\left[H\left(q\left(k\right|x)\right)-\lambda H\left(\overline{q}\left(k\right)\right)\right],$$

(10)

where the first term minimizes the uncertainty of the code assignment for a given input (ensuring deterministic quantization), and the second term maximizes the entropy of the marginal code distribution $\overline{q}\left(k\right)$ to prevent codebook collapse. Binary Spherical Quantization (BSQ) [108] further refines this paradigm by projecting embeddings onto a high-dimensional hypersphere before binarization. By exploiting the geometric properties of the hypersphere, BSQ ensures that the quantization error remains bounded and that the binary codes are more semantically separable compared to standard Euclidean binarization. WeTok [109,110] introduces Group-wise LFQ to strike a balance between representation compactness and expressiveness. Instead of treating the entire latent vector as a single binary code, WeTok splits the token channels into multiple groups similar to PQ [111], applies LFQ within each group, and concatenates the resulting indices. This approach enables the model to capture multi-scale semantic information while maintaining the efficiency of lookup-free quantization.

3.2.3. Optimizing Compression Efficiency

To alleviate the computational burden on downstream generative tasks, maximizing the information density per token—thereby increasing the effective compression rate—is essential. We categorize recent efforts into per-token optimization and global compression strategies.

Per-token Perspective. Standard vector quantization often suffers from a trade-off between codebook size and reconstruction quality. Product Quantization (PQ) [111] addresses this by decomposing high-dimensional vectors into lower-dimensional subspaces and quantizing each independently, effectively expanding the representational capacity without increasing the codebook size. Residual Vector Quantization (RVQ) [112,113], widely adopted in models like RQ-VAE, employs a coarse-to-fine strategy. It iteratively quantizes the residual error from the previous step, approximating the latent vector z as a sum of discrete codes:

$$z\approx {\displaystyle \sum _{m=1}^M}{e}_{k_m}^{\left(m\right)},\mathrm{where}{e}_{k_m}^{\left(m\right)}=\mathrm{Quantize}\left(z-{\displaystyle \sum _{j=1}^{m-1}}{e}_{k_j}^{\left(j\right)}\right).$$

(11)

Complementary to this depth-wise residual approach, VAR [114] introduces a multi-scale quantization strategy tailored for visual autoregressive modeling. Instead of refining the residual at a fixed resolution, VAR quantizes the image feature maps into a multi-scale token pyramid (from $1\times 1$ to $K\times K$). This hierarchical tokenization enables the downstream generative model to predict the "next-scale" token map from coarser scales, effectively decomposing the complex image generation task into a structured, coarse-to-fine prediction process. Additive Quantization (AQ) [115] generalizes this concept by approximating vectors as sums of codewords from multiple codebooks without enforcing a strict sequential order, offering even greater flexibility in representation.

Global Compression Perspective. While per-token methods optimize the information content of individual codes, global strategies focus on reducing the total number of tokens required to represent an image. DC-AE [37,116] targets the computational bottleneck in high-resolution synthesis by scaling the spatial downsampling factor to extreme levels ($f\in \{32,64\}$). To mitigate the severe information loss associated with such aggressive compression, it introduces a Residual Autoencoding mechanism and Decoupled High-Resolution Adaptation, achieving significant inference acceleration while preserving visual fidelity. Taking a different approach, TiTok [101] departs from the traditional grid-based tokenization. It adopts a Transformer-based framework (specifically, a Q-Former architecture [117]), in which a set of learnable latent queries interacts with image features via cross-attention. This mechanism decouples the number of tokens from the image resolution, allowing the model to compress visual data into a compact, fixed-length sequence of 1D tokens, thereby facilitating highly efficient generation.

3.2.4. Enforcing Disentanglement

Information-Theoretic Disentanglement. To enhance the interpretability of token representations, $\beta$-VAE [118,119] introduces a hyperparameter $\beta$ to modulate the information bottleneck. The objective is formulated as:

$${\mathcal{L}}_{\beta \text{-}\mathrm{VAE}}={\mathbb{E}}_{q_{\varphi }\left(z\right|x)}\left[log{p}_{\theta }\left(x\right|z)\right]-\beta \mathrm{KL}\left(q_{\varphi }\left(z\right|x)\parallel p\left(z\right)\right).$$

(12)

While $\beta >1$ promotes disentanglement, it often necessitates a trade-off with reconstruction quality. To address this, ControlVAE [120] formulates KL regularization as a feedback control problem, dynamically adjusting $\beta$ to maintain a target information capacity. Similarly, DynamicVAE [121] employs an adaptive schedule to balance latent utilization and reconstruction throughout training.

However, penalizing the entire KL term indiscriminately suppresses useful mutual information. FactorVAE [122] and $\beta$-TCVAE [123] refine this by decomposing the KL term:

$$\begin{array}{cc}\hfill {\mathbb{E}}_{p\left(x\right)}\left[\mathrm{KL}(q\left(z\right|x)\parallel p\left(z\right))\right]& =\underset{\mathrm{Mutual}\mathrm{Info}.}{\underbrace{I(x;z)}}+\underset{\mathrm{Total}\mathrm{Correlation}}{\underbrace{\mathrm{KL}(q\left(z\right)\parallel {\prod }_{j}q\left(z_j\right))}}\hfill \\ \hfill & +\underset{\mathrm{Dimension}\text{-}\mathrm{wise}\mathrm{KL}}{\underbrace{{\sum }_j\mathrm{KL}(q\left(z_j\right)\parallel p\left(z_j\right))}}.\hfill \end{array}$$

(13)

By specifically penalizing the Total Correlation (TC) term, these methods enforce statistical independence among latent dimensions without compromising the information content required for reconstruction. Alternatively, DIP-VAE achieves disentanglement via moment matching, constraining the aggregated posterior’s covariance to be diagonal.

4. Towards Unified Vision Tokenization

The advent of Large Language Models (LLMs) and AI-Generated Content (AIGC) has reshaped the requirements for visual tokenization, as shown in Figure 5. Traditional tokenizers emphasized either reconstruction fidelity (e.g., VQGAN) or discriminative semantics (e.g., CLIP), whereas modern systems require a unified tokenizer. Such tokenizers must simultaneously encode strong semantics for multimodal understanding and fine-grained details for high-fidelity generation. This section reviews recent efforts to bridge semantic understanding and pixel-level reconstruction.

4.1. Single Encoder

4.1.1. Enhancing Semantic Information

As illustrated in Figure 3, this paradigm begins with a reconstruction objective and introduces additional training signals to enrich semantic representations, improving both the reconstructability and semantic density of visual tokens.

Semantic Distillation. As shown in Figure 3(a), a common strategy distills knowledge from pretrained vision foundation models (VFMs) [5,36,57] into the tokenizer encoder during reconstruction training. This encourages representations that are both reconstructive and semantically meaningful.

Inspired by REPA [124], VA-VAE [125] introduces semantic distillation from VFMs into visual tokenizers, improving generation; AVFM [126] further shows these tokens are more discriminative than conventional VAEs [6]. MAETok [127] learns richer semantics via masked image modeling while compressing images into 1D tokens, and GigaTok [128] scales the tokenizer to 3B parameters with semantic distillation for stronger autoregressive generation. Ming-UniVision [12] advances unified tokenization by adding masked feature prediction and a causal semantic decoder, enabling a single tokenizer for both understanding and generation and outperforming dual-tokenizer designs (e.g., VAE+CLIP). SSDD [129]’s key design is a REPA-inspired pixel diffusion decoder that leverages transformer components and distillation to deliver GAN-free, single-step image tokenization with stronger reconstruction quality and faster sampling. RecTok [21] studies the reconstruction–semantics trade-off and proposes flow-based distillation to scale token dimensionality while improving reconstruction, generation, and discrimination.

Language Supervision. As illustrated in Figure 3(c)-(d), another direction aligns visual tokens with text through contrastive learning or caption supervision. ImageFolder [130] uses product quantization [111] to split tokens into low-level and high-level codes, supervising high-level codes with contrastive alignment to text. UniTok [131] adopts multi-codebook quantization and contrastive learning to support both generation and understanding. AToken [132] improves semantic quality using contrastive and image-text distillation losses while removing GAN supervision; it also extends unified tokenization to video and 3D. MANZANO [133] introduces image captioning as an auxiliary objective, using a single encoder with lightweight adapters and a caption decoder conditioned on visual tokens.

Table 1. Comprehensive Survey of Unified Tokenizers (Part 1/2). This section covers Single Encoder methods (Enhancing and Preserving Semantics). We list the datasets used for tokenizer training, the tokenizer architectures, and the pretrained models leveraged by each method, and we summarize the key highlights of each approach.

Tokenizer	Type	Data	Arch.	Pretrained Model		Highlight	Date
				High-level	Low-level
Single Encoder (Enhancing Semantics)
ImageFolder [130]	C. L.	ImageNet-1K	ViT	DINOv2	-	Decouples code entry into low-level and high-level via product quantization.	2024.10
VQ-KD [134]	Distill.	ImageNet-1K	CNN	CLIP	-	Aligning image tokenizers with semantic features, rather than just pixels, significantly improves autoregressive image generation.	2024.11
VA-VAE [125]	Distill.	ImageNet-1K	CNN	DINOv2	-	Using semantic information to mitigate dimension dilemma.	2025.01
MAETok [127]	Distill.	ImageNet-1K	ViT	DINOv2	-	Leverageing feature reconstruction to learn semantically rich 1D representations.	2025.02
UniTok [131]	C. L.	DataComp-1B	ViT+CNN	CLIP	-	Adopts Multi-Codebook Quantization; aligns text features via contrastive learning.	2025.02
GigaTok [128]	Distill.	ImageNet-1K	ViT+CNN	DINOv2	-	Scaling visual tokenizers to 3 billion parameters.	2025.04
ETT [135]	LM	SA-1B+OpenImages+LAION	CNN	Qwen2.5	IBQ	Jointly optimizing vision tokenizers with downstream tasks boosts multimodal performance.	2025.05
AToken [132]	C. L.	DFN+OpenImages+Internal Data+WebVid+TextVR+Panda70M+Objaverse	ViT	SigLIP2	-	Unified tokenization for image, video, and 3D data using a single tokenizer.	2025.09
MANZANO [133]	LM	CC3M&12M+COYO-700M+VeCap+Internal Data	ViT	CLIP	-	Generates continuous and discrete tokens via separate adapters.	2025.09
Ming-Tok [12]	Distill.	Internal Data	ViT	DINOv2	-	Training a unified tokenizer for autoregressive models via feature reconstruction.	2025.10
VTP [136]	S.L.+C.L.	277M subset of DataComp-1B	ViT	-	-	Utilizes CLIP, DINO, and reconstruction losses; validated scaling on large datasets.	2025.12
RecTok [21]	Distill.	ImageNet-1K	ViT	DINOv3	-	Implements reconstruction and alignment in forward flow to resolve dimensionality issues.	2025.12
GloTok [137]	Distill.	ImageNet-1K	CNN	DINOv2	-	GloTok leverages global relations to unify semantic distribution for superior image generation.	2025.12
PyraTok [138]	Distill.	Droplet-10M+OpenVid-1M+UltraVideo	ViT+CNN	Qwen2.5-VL+DINOv3	Wan2.2	PyraTok aligns pyramidal tokens with language for unified video understanding and generation.	2026.01
Single Encoder (Preserving Semantics)
EMU2 [139]	Frozen	LAION-COCO+LAION-Aesthetics	ViT+CNN	CLIP	-	Uses frozen CLIP as tokenizer; employs trainable SDXL as pixel decoder.	2024.05
VILA-U [140]	C. L.	COYO-700M	ViT	SigLIP	-	Adapts to reconstruction by fine-tuning SigLIP; preserves semantics via contrastive loss.	2024.09
Divot [141]	Frozen	WebVid-10M+Panda-70M	ViT	ViT-H	DynamiCrafter	Utilizing diffusion to power video tokenizer for comprehension and generation.	2024.12
QLIP [142]	C. L.	DataComp-1B	ViT	CLIP	-	Two-stage: contrastive loss first, then freezes encoder to preserve semantics.	2025.02
DualToken [143]	Self-Distill.	CC12M	ViT	SigLIP	-	Uses SigLIP shallow features for recon, deep for semantics; aligns via concatenation.	2025.03
TA-Tok [144]	Self-Distill.	LAION	ViT	SigLIP2	-	Initializes codebook with LLM embeddings to align visual tokens with text features.	2025.07
VFMTok [145]	Frozen	ImageNet-1K	ViT	DINOv2	-	Enhances reconstruction with multi-level features; captures detail via deformable transformer.	2025.07
UniLIP [15]	Self-Distill.	BLIP3-o pretraining data 27M	ViT+CNN	InternViT	-	Two-stage training: stage one trains decoder only, stage two implies self-distillation loss.	2025.07
AVFM [126]	Self-Distill.	ImageNet-1K+LAION	ViT+CNN	DINOv2	-	Adapts DINOv2 to generation tasks via three-stage training; validated on LAION.	2025.09
UniFlow [146]	Self-Distill.	ImageNet-1K	ViT	InternViT	-	Performs self-distillation on multi-level features; uses flow matching pixel decoder.	2025.10
RAE [102]	Frozen	ImageNet-1K	ViT	DINOv2	-	SOTA generative performance with frozen DINOv2; realizes training in high-dim space.	2025.10
VFM-VAE [147]	Frozen	ImageNet-1K	ViT+CNN	SigLIP2	-	Obtains visual tokens via multi-level feature fusion; reconstructs using global/local features.	2025.11
DINO-Tok [148]	Frozen	ImageNet-1K	ViT	DINOv2	-	Explicitly decouples texture and semantic features; concatenates both in feature dimension.	2025.11
VQRAE [149]	Self-Distill.	BLIP3-o pretraining data 27M	ViT	InternViT	-	Uses continuous representations for understanding; post-quantization for generation.	2025.11
VGT [150]	Self-Distill.	BLIP3-o pretraining data 27M+CC12M+JourneyDB+200K HQ	ViT+CNN	QwenViT	DCAE	Empowers VLMs with efficient visual generation by aligning semantic encoders with pixel decoders.	2025.11
FAE [151]	Frozen	ImageNet-1K+CC12M	ViT	DINOv2	-	Trains an asymmetric VAE in high-dim semantic space; retains semantics while reducing dims.	2025.12
UAE [20]	Self-Distill.	ImageNet-1K	ViT	DINOv2	-	Freq domain: preserves low-freq high-level, amplifies high-freq low-level info.	2025.12
DINO-SAE [152]	Self-Distill.	ImageNet-1K	ViT+CNN	DINOv3	-	Bridges semantic and pixel reconstruction on spherical manifolds for high-fidelity generation.	2026.01

Table 1. Comprehensive Survey of Unified Tokenizers (Part 1/2). This section covers Single Encoder methods (Enhancing and Preserving Semantics). We list the datasets used for tokenizer training, the tokenizer architectures, and the pretrained models leveraged by each method, and we summarize the key highlights of each approach.

Tokenizer	Type	Data	Arch.	Pretrained Model		Highlight	Date
				High-level	Low-level
Single Encoder (Enhancing Semantics)
ImageFolder [130]	C. L.	ImageNet-1K	ViT	DINOv2	-	Decouples code entry into low-level and high-level via product quantization.	2024.10
VQ-KD [134]	Distill.	ImageNet-1K	CNN	CLIP	-	Aligning image tokenizers with semantic features, rather than just pixels, significantly improves autoregressive image generation.	2024.11
VA-VAE [125]	Distill.	ImageNet-1K	CNN	DINOv2	-	Using semantic information to mitigate dimension dilemma.	2025.01
MAETok [127]	Distill.	ImageNet-1K	ViT	DINOv2	-	Leverageing feature reconstruction to learn semantically rich 1D representations.	2025.02
UniTok [131]	C. L.	DataComp-1B	ViT+CNN	CLIP	-	Adopts Multi-Codebook Quantization; aligns text features via contrastive learning.	2025.02
GigaTok [128]	Distill.	ImageNet-1K	ViT+CNN	DINOv2	-	Scaling visual tokenizers to 3 billion parameters.	2025.04
ETT [135]	LM	SA-1B+OpenImages+LAION	CNN	Qwen2.5	IBQ	Jointly optimizing vision tokenizers with downstream tasks boosts multimodal performance.	2025.05
AToken [132]	C. L.	DFN+OpenImages+Internal Data+WebVid+TextVR+Panda70M+Objaverse	ViT	SigLIP2	-	Unified tokenization for image, video, and 3D data using a single tokenizer.	2025.09
MANZANO [133]	LM	CC3M&12M+COYO-700M+VeCap+Internal Data	ViT	CLIP	-	Generates continuous and discrete tokens via separate adapters.	2025.09
Ming-Tok [12]	Distill.	Internal Data	ViT	DINOv2	-	Training a unified tokenizer for autoregressive models via feature reconstruction.	2025.10
VTP [136]	S.L.+C.L.	277M subset of DataComp-1B	ViT	-	-	Utilizes CLIP, DINO, and reconstruction losses; validated scaling on large datasets.	2025.12
RecTok [21]	Distill.	ImageNet-1K	ViT	DINOv3	-	Implements reconstruction and alignment in forward flow to resolve dimensionality issues.	2025.12
GloTok [137]	Distill.	ImageNet-1K	CNN	DINOv2	-	GloTok leverages global relations to unify semantic distribution for superior image generation.	2025.12
PyraTok [138]	Distill.	Droplet-10M+OpenVid-1M+UltraVideo	ViT+CNN	Qwen2.5-VL+DINOv3	Wan2.2	PyraTok aligns pyramidal tokens with language for unified video understanding and generation.	2026.01
Single Encoder (Preserving Semantics)
EMU2 [139]	Frozen	LAION-COCO+LAION-Aesthetics	ViT+CNN	CLIP	-	Uses frozen CLIP as tokenizer; employs trainable SDXL as pixel decoder.	2024.05
VILA-U [140]	C. L.	COYO-700M	ViT	SigLIP	-	Adapts to reconstruction by fine-tuning SigLIP; preserves semantics via contrastive loss.	2024.09
Divot [141]	Frozen	WebVid-10M+Panda-70M	ViT	ViT-H	DynamiCrafter	Utilizing diffusion to power video tokenizer for comprehension and generation.	2024.12
QLIP [142]	C. L.	DataComp-1B	ViT	CLIP	-	Two-stage: contrastive loss first, then freezes encoder to preserve semantics.	2025.02
DualToken [143]	Self-Distill.	CC12M	ViT	SigLIP	-	Uses SigLIP shallow features for recon, deep for semantics; aligns via concatenation.	2025.03
TA-Tok [144]	Self-Distill.	LAION	ViT	SigLIP2	-	Initializes codebook with LLM embeddings to align visual tokens with text features.	2025.07
VFMTok [145]	Frozen	ImageNet-1K	ViT	DINOv2	-	Enhances reconstruction with multi-level features; captures detail via deformable transformer.	2025.07
UniLIP [15]	Self-Distill.	BLIP3-o pretraining data 27M	ViT+CNN	InternViT	-	Two-stage training: stage one trains decoder only, stage two implies self-distillation loss.	2025.07
AVFM [126]	Self-Distill.	ImageNet-1K+LAION	ViT+CNN	DINOv2	-	Adapts DINOv2 to generation tasks via three-stage training; validated on LAION.	2025.09
UniFlow [146]	Self-Distill.	ImageNet-1K	ViT	InternViT	-	Performs self-distillation on multi-level features; uses flow matching pixel decoder.	2025.10
RAE [102]	Frozen	ImageNet-1K	ViT	DINOv2	-	SOTA generative performance with frozen DINOv2; realizes training in high-dim space.	2025.10
VFM-VAE [147]	Frozen	ImageNet-1K	ViT+CNN	SigLIP2	-	Obtains visual tokens via multi-level feature fusion; reconstructs using global/local features.	2025.11
DINO-Tok [148]	Frozen	ImageNet-1K	ViT	DINOv2	-	Explicitly decouples texture and semantic features; concatenates both in feature dimension.	2025.11
VQRAE [149]	Self-Distill.	BLIP3-o pretraining data 27M	ViT	InternViT	-	Uses continuous representations for understanding; post-quantization for generation.	2025.11
VGT [150]	Self-Distill.	BLIP3-o pretraining data 27M+CC12M+JourneyDB+200K HQ	ViT+CNN	QwenViT	DCAE	Empowers VLMs with efficient visual generation by aligning semantic encoders with pixel decoders.	2025.11
FAE [151]	Frozen	ImageNet-1K+CC12M	ViT	DINOv2	-	Trains an asymmetric VAE in high-dim semantic space; retains semantics while reducing dims.	2025.12
UAE [20]	Self-Distill.	ImageNet-1K	ViT	DINOv2	-	Freq domain: preserves low-freq high-level, amplifies high-freq low-level info.	2025.12
DINO-SAE [152]	Self-Distill.	ImageNet-1K	ViT+CNN	DINOv3	-	Bridges semantic and pixel reconstruction on spherical manifolds for high-fidelity generation.	2026.01

Visual Self-Supervised Learning. As illustrated in Figure 3(b), VTP [136] incorporates DINOv2-style self-supervised learning [57] to strengthen semantic representations. Unlike prior approaches that rely on pretrained text encoders, VTP trains the text encoder jointly and demonstrates strong scalability across tasks such as generation and classification.

4.1.2. Preserving Semantic Information

This direction starts from strong high-level tokenizers—typically vision foundation models (VFMs)—and converts them into unified tokenizers by adding a pixel-level decoder. The key challenge is preserving semantic information while enabling high-fidelity reconstruction. As illustrated in Figure 4, existing approaches fall into two streams [13,14,18]: (1) freezing VFMs to preserve semantics while relying on powerful decoders or multi-level features for reconstruction, and (2) fine-tuning VFMs to improve reconstruction while preventing semantic degradation.

Frozen Vision Foundation Models. To preserve pretrained semantics, some methods freeze the VFM encoder and shift modeling capacity to the decoder. Emu2 [139] uses a frozen CLIP encoder and an SDXL U-Net decoder for reconstruction, but reconstruction fidelity is limited because CLIP features lack low-level details.

RAE [102] and FAE [151] show that powerful decoders (e.g., deep Vision Transformers) can reconstruct images from highly compressed semantic tokens, although pixel-level fidelity (PSNR/SSIM) still lags behind low-level tokenizers [6,85].

Other works exploit intermediate features in VFMs, which retain more visual detail than final-layer representations. VFMTok [145], DINO-Tok [148], and VFM-VAE [147] therefore reconstruct images from multi-level features while preserving semantic representations.

Finetuning Vision Foundation Models. While freezing preserves semantics, it limits reconstruction quality [15,146]. Another direction fine-tunes VFM encoders with careful regularization to avoid semantic drift. One strategy retains contrastive objectives during fine-tuning. VILA-U [140] and QLIP [142] combine reconstruction losses with image–text contrastive learning, maintaining language alignment while enabling reconstruction.

Table 2. Comprehensive Survey of Unified Tokenizers (Part 2/2). This section covers Dual Encoder methods (Parallel and Cascade Encoders).

Tokenizer	Type	Data	Arch.	Pretrained Model		Highlight	Date
				High-level	Low-level
Dual Encoder (Parallel Encoders)
MUSE-VL [22]	Parallel	ImageNet-1K+CC12M	ViT+CNN	SigLIP	-	Concatenates high-level and low-level features, followed by quantization.	2024.11
TokenFlow [18]	Parallel	LAION+COYO-700M	ViT	SigLIP	-	Shared mapping strategy; considers both high-level and low-level info during quantization.	2024.12
TA-TiTok [153]	Parallel	DataComp-1B	ViT	CLIP	-	Receives both image and text features during pixel decoding.	2025.01
ILLUME+ [154]	Parallel	ImageNet-1K	ViT+CNN	QwenViT	-	Fuses features only for pixel reconstruction; requires both for generation/understanding.	2025.04
UniToken [155]	Parallel	ShareGPT4V+LLaVA+ALLaVA	ViT+CNN	SigLIP	VQGAN	Concatenates high-level and low-level features before feeding into LLM.	2025.04
SemHiTok [23]	Parallel	ImageNet-1K+50M subset of COYO-700M	ViT	SigLIP	-	Hierarchical quantization: quantizes semantics first, then selects codebook for pixel features.	2025.03
Show-o2 [16]	Parallel	75M Internal Data	ViT+CNN	SigLIP	Wan2.1	Using spatial-temporal fusion to obtain the unified representation.	2025.06
SVGTok [156]	Parallel	ImageNet-1K	ViT+CNN	DINOv3	-	Introduces residual encoder for low-level info; fuses with DINOv3 features.	2025.10
EMMA [157]	Parallel	LLaVA+LAION+X2I2+OmniEdit+Synthetic	ViT+CNN	SigLIP2	DCAE	Fuses the high-level and low-level tokens through concatenation.	2025.12
Dual Encoder (Cascade Encoders)
Harmon [17]	Cascade	103M Public Data	ViT+CNN	MAR	SD-VAE	Introducing MAR as the visual tokenizer, harmonize high-level and low-level information.	2025.03
USP [158]	Cascade	ImageNet-1K	ViT+CNN	-	SD-VAE	Performs mask reconstruction learning in the VAE feature space.	2025.03
TokLIP [14]	Cascade	CapsFusion+CC12M+LAION-High Resolution	ViT	SigLIP2	VQGAN	Trains high-level tokenizer in VQGAN feature space; adapts to AR model.	2025.05
TUNA [13]	Cascade	Internal Data	ViT+CNN	SigLIP2	Wan2.2	End-to-end training of high-level tokenizer on VAE.	2025.12
PS-VAE [19]	Cascade	ImageNet-1K	ViT+CNN	DINOv2	-	Trains VAE in high-level feature space to reduce dimensionality.	2025.12
OpenVision3 [159]	Cascade	DataComp-1B	ViT+CNN	-	FLUX.1-dev	Incorporating contrastive and caption loss for semantic learning, while VAE feature reconstruction preserves visual details.	2026.01

Table 2. Comprehensive Survey of Unified Tokenizers (Part 2/2). This section covers Dual Encoder methods (Parallel and Cascade Encoders).

Tokenizer	Type	Data	Arch.	Pretrained Model		Highlight	Date
				High-level	Low-level
Dual Encoder (Parallel Encoders)
MUSE-VL [22]	Parallel	ImageNet-1K+CC12M	ViT+CNN	SigLIP	-	Concatenates high-level and low-level features, followed by quantization.	2024.11
TokenFlow [18]	Parallel	LAION+COYO-700M	ViT	SigLIP	-	Shared mapping strategy; considers both high-level and low-level info during quantization.	2024.12
TA-TiTok [153]	Parallel	DataComp-1B	ViT	CLIP	-	Receives both image and text features during pixel decoding.	2025.01
ILLUME+ [154]	Parallel	ImageNet-1K	ViT+CNN	QwenViT	-	Fuses features only for pixel reconstruction; requires both for generation/understanding.	2025.04
UniToken [155]	Parallel	ShareGPT4V+LLaVA+ALLaVA	ViT+CNN	SigLIP	VQGAN	Concatenates high-level and low-level features before feeding into LLM.	2025.04
SemHiTok [23]	Parallel	ImageNet-1K+50M subset of COYO-700M	ViT	SigLIP	-	Hierarchical quantization: quantizes semantics first, then selects codebook for pixel features.	2025.03
Show-o2 [16]	Parallel	75M Internal Data	ViT+CNN	SigLIP	Wan2.1	Using spatial-temporal fusion to obtain the unified representation.	2025.06
SVGTok [156]	Parallel	ImageNet-1K	ViT+CNN	DINOv3	-	Introduces residual encoder for low-level info; fuses with DINOv3 features.	2025.10
EMMA [157]	Parallel	LLaVA+LAION+X2I2+OmniEdit+Synthetic	ViT+CNN	SigLIP2	DCAE	Fuses the high-level and low-level tokens through concatenation.	2025.12
Dual Encoder (Cascade Encoders)
Harmon [17]	Cascade	103M Public Data	ViT+CNN	MAR	SD-VAE	Introducing MAR as the visual tokenizer, harmonize high-level and low-level information.	2025.03
USP [158]	Cascade	ImageNet-1K	ViT+CNN	-	SD-VAE	Performs mask reconstruction learning in the VAE feature space.	2025.03
TokLIP [14]	Cascade	CapsFusion+CC12M+LAION-High Resolution	ViT	SigLIP2	VQGAN	Trains high-level tokenizer in VQGAN feature space; adapts to AR model.	2025.05
TUNA [13]	Cascade	Internal Data	ViT+CNN	SigLIP2	Wan2.2	End-to-end training of high-level tokenizer on VAE.	2025.12
PS-VAE [19]	Cascade	ImageNet-1K	ViT+CNN	DINOv2	-	Trains VAE in high-level feature space to reduce dimensionality.	2025.12
OpenVision3 [159]	Cascade	DataComp-1B	ViT+CNN	-	FLUX.1-dev	Incorporating contrastive and caption loss for semantic learning, while VAE feature reconstruction preserves visual details.	2026.01

Another widely used strategy is self-distillation, where the fine-tuned model is constrained to match a frozen teacher. Representative methods include DualToken [143], TA-Tok [144], UniLIP [15], AVFM [126], UniFlow [146], VQRAE [149], and UAE [20]. DualToken [143] reconstructs from shallow features while distilling semantics from deeper layers. TA-Tok [144] aligns visual tokens with LLM embeddings. UniLIP [15] and AVFM [126] adopt multi-stage training to preserve semantics during reconstruction. UniFlow [146] applies multi-layer self-distillation with a flow-based decoder. UAE [20] decomposes tokens via FFT, preserving low-frequency semantics and reconstructing high-frequency details.

4.2. Dual Encoder

A single encoder often struggles to balance semantic richness and reconstruction fidelity. Dual-encoder designs therefore decouple high-level and low-level feature extraction and merge them into a unified token space.

4.2.1. Parallel Architectures

As shown in Figure 6(a), parallel architectures use multiple visual encoders to capture low-level details and high-level semantics, then fuse them for multimodal tasks.

Several models—Unified-IO 2 [9], Janus [10,160,161], UniFluid [162], and Bagel [11]—adopt two tokenizers, typically a VAE-style encoder for generation and a CLIP-style encoder for understanding, as shown in Figure 5 (b). However, the representations remain disjoint, forcing the backbone (e.g., an LLM) to bridge them, which increases training complexity and slows convergence [12,13]. Tasks such as image editing also require both semantics and detail, motivating unified representations [19].

Recent work focuses on feature fusion. MUSE-VL [22] and UniToken [155] concatenate semantic and pixel features, while TokenFlow [18] introduces weighted fusion. ILLUME+ [154] generates hierarchical tokens, and SemHiTok [23] performs semantic-guided hierarchical quantization. Other methods explore richer fusion strategies. Show-o2 [16] combines SigLIP [36] and VAE features through spatiotemporal fusion. TA-TiTok [153] introduces text-aware tokenization with a frozen text encoder. SVGTok [156] adds a lightweight residual encoder to recover high-frequency details, while EMMA [157] concatenates SigLIP and DCAE [37] features into unified tokens.

4.2.2. Cascade Architecture

As illustrated in Figure 6(b), cascade architectures adopt progressive tokenization, gradually transforming task-specific features into unified representations.

USP [158] applies masked image modeling on the feature space of a frozen VAE, enabling semantic abstraction while preserving visual details. TokLIP [14] extends this paradigm to autoregressive models by placing a causal representation encoder on top of VQGAN features and aligning them with CLIP semantics. The AR backbone consumes these tokens for both understanding and generation while predicting VQGAN codes for reconstruction. In contrast, TUNA [13] adopts end-to-end training, jointly optimizing the tokenizer for understanding and generation without auxiliary objectives. Experiments show that a trainable unified tokenizer outperforms architectures relying on frozen visual encoders. In [19], PS-VAE introduces an additional autoencoder to compress high-level features, combining reconstruction with self-distillation to preserve semantics. On the other hand, OpenVision3 [159] builds a semantic encoder on top of a pretrained VAE [163], preserving details via VAE feature reconstruction while aligning features with text using contrastive and captioning losses. Overall, cascade architectures emphasize progressive abstraction, explicitly modeling the transition from low-level details to unified representations.

5. Downstream Tasks and Benchmarks

Evaluating visual tokenizers requires multiple criteria, as different architectures emphasize different capabilities. While low-level tokenizers prioritize signal fidelity, high-level and unified models must also demonstrate semantic proficiency across discriminative and generative tasks. This section summarizes common evaluation protocols and benchmarks.

5.1. High-Level Semantic Evaluation

5.1.1. Global Semantic Capability

Global capability is mainly evaluated on ImageNet classification and cross-modal retrieval.

ImageNet Classification: Table 3 reports results under zero-shot (z.s.), linear probing (l.p.), and fine-tuning (Tune). Weakly supervised models such as SigLIP 2 and the Perception Encoder (PE) achieve strong zero-shot performance (up to 85.4%), while self-supervised models like DINOv3 (7B) reach the best linear probing accuracy of 88.4%.

Retrieval Performance: On Flickr and COCO [164], models are evaluated via text-to-image (T2I) and image-to-text (I2T) retrieval. SigLIP 2 and PE lead this category, indicating strong cross-modal alignment.

5.1.2. Spatial Dense Capability

Spatial capability measures the ability to capture fine-grained, localized information.

Detection and Instance Segmentation: On COCO [164], models are evaluated by box and mask mAP. Supervised backbones such as Swin-L and ConvNeXt-XL provide strong baselines, while self-supervised models like EVA (ViT-1B) and DINOv3 (7B) achieve competitive spatial performance, with DINOv3 reaching 65.6 box mAP.

Semantic Segmentation: Semantic segmentation is measured by mean IoU (mIoU) on ADE. A challenging setting is dense linear probing (marked with *), where encoder weights remain frozen. Recent models such as DINOv3 (55.9*), PE (41.5*), and TIPS (49.4*) show that their learned representations support dense prediction without task-specific fine-tuning.

5.1.3. Analysis

The benchmarks show a clear trend: high-level tokenizers are becoming more versatile, supporting both global classification and pixel-level localization. Scaling model size (from ∼300M to 7B parameters) further improves robustness and feature granularity.

5.2. Low-Level Reconstruction Evaluation

For low-level tokenizers, the goal is to compress visual data with minimal information loss while supporting downstream generation. Evaluation is typically conducted on standard datasets such as ImageNet-1K.

5.2.1. Reconstruction Fidelity

Reconstruction fidelity is evaluated using three metrics: rFID, PSNR, and SSIM [178]. rFID (reconstruction FID) measures the distributional divergence between original and reconstructed images in deep feature space and serves as the primary perceptual quality metric. PSNR (Peak Signal-to-Noise Ratio) and SSIM (Structural Similarity Index) complement rFID by assessing pixel-level accuracy and structural similarity.

5.2.2. Codebook Analysis

For discrete tokenizers, codebook utilization is critical. Codebook Usage indicates whether the model avoids codebook collapse and effectively exploits the discrete vocabulary.

5.2.3. Analysis

Table 4 compares state-of-the-art low-level tokenizers on ImageNet-1K. Several key observations emerge.

Evolution of Discrete Tokenizers. Early models such as VQGAN [85] exhibited high reconstruction error (rFID 4.98) and low codebook utilization (5.9%), reflecting severe codebook collapse. Recent quantization advances have significantly improved performance. Methods such as BSQ [108] and WeTok [109] achieve nearly full codebook utilization and strong perceptual fidelity; notably, WeTok reaches an rFID of 0.19, showing that discrete tokenizers can rival or surpass continuous counterparts.

Continuous vs. Discrete Gap. Continuous tokenizers (e.g., VAEs) historically achieved better reconstruction due to unconstrained latent spaces. Models such as DC-AE [37] and SD3-VAE [168] remain strong (rFID ≈0.6–1.0). However, recent discrete methods—including Open-MAGVIT2 [166], BSQ [108], and WeTok [109]—have largely closed this gap while preserving the advantages of discrete representations for autoregressive modeling.

Impact of Foundation Models. Another trend is integrating pretrained vision foundation models into tokenization. Methods such as VA-VAE [125] and RAE [102], which leverage DINOv2 features, achieve strong reconstruction (rFID 0.28 and 0.49), suggesting that semantic priors from large-scale models enhance tokenizer capacity.

Trade-offs in 1D Tokenization. 1D tokenization approaches such as TiTok [101] enable extreme compression but still trail 2D spatial tokenizers in reconstruction quality (rFID 2.21), highlighting the challenge of balancing compression and fidelity.

5.3. Unified Multimodal Evaluation

With the emergence of unified tokenizers (e.g., VILA-U), evaluation has expanded to MLLMs, assessing both generation and understanding within a single framework.

5.3.1. Multimodal Understanding

We evaluate multimodal understanding on benchmarks covering: VQA: VQAv2 [179], GQA [180], VizWiz [181]; comprehensive evaluation: MMBench [182], MME [183], MMMU [184], SEED-Bench; hallucination: POPE [185], HallusionBench [186].

Task-specific tokenizers (e.g., Show-o, Harmon) benefit from specialized optimization, but unified tokenizers such as BLIP-3o [177] and VQRAE [149] achieve competitive results. On OCRBench, MANZANO [133] scores 86.3, surpassing EMU3 [171] (68.7), though some task-specific models (e.g., Lumina-DiMOO) still lead certain metrics (MMBench 84.5).

Among unified methods, single-encoder designs generally perform best. BLIP-3o reaches 2329.7 on MME, compared with 1993.8 for the best dual-encoder model (SemHiTok), suggesting tighter visual–text alignment in single-encoder architectures.

5.3.2. Visual Generation

We evaluate two categories of generation: class-conditional generation and multimodal generation. Class-conditional generation synthesizes images from semantic labels and is evaluated on ImageNet-1K using gFID, IS, Precision, and Recall.

As shown in Table 5, continuous tokenizers generally achieve higher fidelity than discrete ones. For example, SD-VAE [31] achieves gFID 1.26, outperforming VQGAN [85] (5.20) and LlamaGen [86] (3.09), suggesting that quantization error may limit discrete tokenizers in this setting.

Table 5. Comparison of tokenizers on class-conditional generation. Evaluated on ImageNet-1K (256×256) [38]. Metrics include gFID, IS, Precision, and Recall. For tokenizers with multiple variants, we report the version used in their main experiments.

Method	Generation Model			ImageNet-1K w/CFG
	Backbone	Para.	Epochs	gFID↓	IS↑	Precision↑	Recall↑
Low-level Tokenzier (Discrete)
VQGAN [85]	Discrete	-	-	5.20	280.3	0.629	-
LlamaGen [86]	LlamaGen-XXL	1.4B	300	3.09	253.6	0.83	0.53
Open-MAGVIT2 [166]	Open-MAGVIT2-AR-XL	1.5B	350	2.33	271.8	0.84	0.54
IBQ [105]	IBQ-XXL	2.1B	450	2.05	286.7	0.83	0.57
WeTok [109]	WeTok-AR-XL	1.5B	1000	2.31	276.6	0.84	0.55
FVQ [106]	LlamaGen-XL	775M	350	2.07	287.0	0.83	0.58
Low-level Tokenzier (Continuous)
SD-VAE [31]	DDT	675M	800	1.26	310.6	0.79	0.65
l-DeTok [169]	MAR-L	437M	800	1.35	-	-	-
TiTok [101]	MaskGIT	177M	-	2.77	199.8	-	-
SoftVQ [167]	SiT-XL	675M	-	1.86	293.6	-	-
Unified Tokenzier (Single Encoder)
VA-VAE [125]	LightningDiT-XL	675M	800	1.35	295.3	0.79	0.65
MAETok [127]	SiT-XL	675M	800	1.67	311.2	-	-
GigaTok [128]	LlamaGen-XXL	1.4B	300	1.98	256.76	0.81	0.62
VFMTok [145]	LlamaGen-XXL	1.4B	200	2.16	272.00	0.83	0.60
AVFM [126]	LightningDiT-XL	675M	800	1.37	293.6	0.79	0.65
ATOKEN [132]	LightningDiT-XL	675M	-	1.56	260.0	0.79	0.63
RAE [102]	DiTDH-XL	839M	800	1.13	262.6	0.78	0.67
VFM-VAE [147]	LightningDiT-XL	675M	560	1.57	254.4	0.80	0.64
FAE [151]	LightningDiT-XL	675M	-	1.29	268.0	0.80	0.64
UAE [20]	-	-	-	1.68	301.6	0.77	0.61
VTP [136]	LightningDiT-XL	675M	80	-	-	-	-
RecTok [21]	DiTDH-XL	839M	600	1.13	289.2	0.79	0.67
Unified Tokenzier (Dual Encoder)
SVGTok [156]	SiT-XL	675M	1400	1.92	264.9	-	-

Table 5. Comparison of tokenizers on class-conditional generation. Evaluated on ImageNet-1K (256×256) [38]. Metrics include gFID, IS, Precision, and Recall. For tokenizers with multiple variants, we report the version used in their main experiments.

Method	Generation Model			ImageNet-1K w/CFG
	Backbone	Para.	Epochs	gFID↓	IS↑	Precision↑	Recall↑
Low-level Tokenzier (Discrete)
VQGAN [85]	Discrete	-	-	5.20	280.3	0.629	-
LlamaGen [86]	LlamaGen-XXL	1.4B	300	3.09	253.6	0.83	0.53
Open-MAGVIT2 [166]	Open-MAGVIT2-AR-XL	1.5B	350	2.33	271.8	0.84	0.54
IBQ [105]	IBQ-XXL	2.1B	450	2.05	286.7	0.83	0.57
WeTok [109]	WeTok-AR-XL	1.5B	1000	2.31	276.6	0.84	0.55
FVQ [106]	LlamaGen-XL	775M	350	2.07	287.0	0.83	0.58
Low-level Tokenzier (Continuous)
SD-VAE [31]	DDT	675M	800	1.26	310.6	0.79	0.65
l-DeTok [169]	MAR-L	437M	800	1.35	-	-	-
TiTok [101]	MaskGIT	177M	-	2.77	199.8	-	-
SoftVQ [167]	SiT-XL	675M	-	1.86	293.6	-	-
Unified Tokenzier (Single Encoder)
VA-VAE [125]	LightningDiT-XL	675M	800	1.35	295.3	0.79	0.65
MAETok [127]	SiT-XL	675M	800	1.67	311.2	-	-
GigaTok [128]	LlamaGen-XXL	1.4B	300	1.98	256.76	0.81	0.62
VFMTok [145]	LlamaGen-XXL	1.4B	200	2.16	272.00	0.83	0.60
AVFM [126]	LightningDiT-XL	675M	800	1.37	293.6	0.79	0.65
ATOKEN [132]	LightningDiT-XL	675M	-	1.56	260.0	0.79	0.63
RAE [102]	DiTDH-XL	839M	800	1.13	262.6	0.78	0.67
VFM-VAE [147]	LightningDiT-XL	675M	560	1.57	254.4	0.80	0.64
FAE [151]	LightningDiT-XL	675M	-	1.29	268.0	0.80	0.64
UAE [20]	-	-	-	1.68	301.6	0.77	0.61
VTP [136]	LightningDiT-XL	675M	80	-	-	-	-
RecTok [21]	DiTDH-XL	839M	600	1.13	289.2	0.79	0.67
Unified Tokenzier (Dual Encoder)
SVGTok [156]	SiT-XL	675M	1400	1.92	264.9	-	-

Table 6. Comparison of unified tokenizers on multimodal generation and understanding. Methods are grouped by tokenizer strategy. For models with multiple variants, we report the best version in their paper.

Method	LLM Backbone	Tokenizer Strategy	Generation			Multimodal Understanding											TextRich
			GenEval	DPG-Bench	WISE	VQAv2	GQA	POPE	MME	MMB	MMMU	MMV	SEED	AI2D	MathV	MMS	OCRBench	TextVQA
Task-Specific Tokenizer (Single Tokenizer)
LWM [170]	LLaMA-2-7B	VQGAN	-	-	-	55.8	44.8	-	-	-	-	-	-	-	-	-	-	-
Transfusion [25]	LLaMA-2-7B	SD-VAE	0.63	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-
Show-o [27]	Phi-1.5-1.3B	MAGVITv2	0.53	67.27	0.28	69.4	58.0	80.0	1097.2	-	26.7	-	-	-	-	-	-	-
EMU3 [171]	8B from scratch	MoVQGAN	0.66	80.60	-	75.1	60.3	85.2	-	58.5	31.6	37.2	-	70.0	-	-	68.7	64.7
D-DiT [172]	SD3-2B	VAE	0.65	-	-	60.1	59.2	84.0	1124.7	-	-	-	-	-	-	-	-	-
Muddit [24]	Meissonic-1B	VQGAN	0.61	-	-	68.2	57.5	-	1107.4	28.4	27.6	-	-	-	-	-	-	-
MMaDA [26]	LLaDA-8B	MAGVITv2	0.63	69.97	0.67	76.7	61.3	86.1	1410.7	68.5	30.2	-	-	-	-	-	-	-
Lumina-DiMOO [173]	LLaDA-8B	VQGAN	0.88	86.04	-	-	-	87.4	1534.2	84.5	58.6	-	-	-	-	-	-	-
Task-Specific Tokenizer (Seperate Tokenizer)
Unified-IO 2 [9]	T5-XXL	VAE + ViT	-	-	-	77.0	-	-	-	-	-	-	-	-	-	-	-	-
Janus [10]	DeepSeek-LLM-1.3B	VQ + SigLIP	0.61	-	-	77.3	59.1	87.0	1338.0	69.4	30.5	34.3	63.7	-	-	-	-	-
JanusFlow [161]	DeepSeek-LLM-1.3B	VQ + SigLIP	0.63	80.09	-	79.8	60.3	88.0	1333.1	74.9	29.3	30.9	70.5	-	-	-	-	-
Janus-Pro [160]	DeepSeek-LLM-7B	VQ + SigLIP	0.80	84.19	-	-	62.0	87.4	1567.1	79.2	41.0	50.0	72.1	-	-	-	-	-
UniFluid [162]	Gemma-2	VAE + CLIP	0.59	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-
MindOmni [174]	QwenVL-2.5-7B	VAE + QwenViT	0.83	-	0.71	-	-	-	-	83.2	51.6	-	-	-	-	-	-	-
Skywork UniPic [175]	Qwen-2.5-7B	MAR + SigLIP2	0.86	85.50	-	-	-	-	-	-	-	-	-	-	-	-	-	-
BAGEL [11]	Qwen-2.5-7B	VAE + SigLIP2	0.82	-	0.70	-	-	-	2388.0	85.0	55.3	67.2	67.2	-	-	73.1	-	-
Unified Tokenizer (Single Encoder)
UniTok [131]	Llama-2-7B	C. L.	-	-	-	76.8	61.1	83.2	1448.0	-	-	33.9	-	-	-	-	-	-
ATOKEN [132]	SlowFast-LLaVA-1.5-7B	C. L.	0.65	-	-	-	-	-	-	-	48.7	-	-	81.2	61.2	-	74.5	-
Ming-Tok [12]	Ling-lite-16B-A3B	Distill.	0.85	-	-	-	-	-	2023.0	78.5	40.3	64.2	-	82.8	66.6	63.7	72.4	-
EMU3.5 [176]	-	Distill.	0.86	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-
EMU2 [139]	Llama-2-33B	Frozen VFMs	-	-	-	84.9	65.1	-	1450.0	65.1	34.1	48.5	62.8	-	-	-	-	66.6
VILA-U [140]	Llama-2-7B	C. L.	-	-	-	75.3	61.1	83.9	1336.0	-	-	27.7	-	-	-	-	-	60.8
QLIP [142]	Vicuna-1.5-7B	C. L.	0.48	78.17	-	78.3	61.8	86.1	1498.3	-	-	-	-	-	-	-	-	55.2
DualToken [143]	Qwen-2.5-3B	Self-Distill.	-	-	-	77.8	-	86.0	1489.2	70.9	38.6	32.5	70.2	-	46.5	-	-	-
BLIP-3o [177]	QwenVL-2.5-7B	Frozen VFMs	0.84	81.60	0.62	83.1	-	-	2329.7	83.5	50.6	66.6	77.5	-	-	-	-	-
UniLIP [15]	InternVL-3-2B	Self-Distill.	0.90	-	0.63	-	-	-	1636.0	80.7	48.7	62.2	75.0	78.6	-	-	-	-
UniFlow [146]	Qwen-2.5-7B	Self-Distill.	-	-	-	-	65.90	89.8	2063.0	83.5	-	-	-	-	-	-	-	81.6
VQRAE [149]	Qwen-2.5-7B	Self-Distill.	0.96	89.78	-	-	-	90.5	1746.8	85.1	61.6	-	77.0	84.8	-	-	-	80.6
PS-VAE [19]	-	Self-Distill.	0.76	83.62	-	-	-	-	-	-	-	-	-	-	-	-	-	-
Unified Tokenizer (Dual Encoder)
Muse-VL [22]	Qwen-2.5-32B	Parallel	0.53	-	-	-	-	-	-	81.8	50.1	-	71.0	79.9	55.9	56.7	-	-
TokenFlow [18]	Qwen-2.5-14B	Parallel	0.55	73.38	-	-	-	-	1922.2	76.8	43.2	48.2	72.6	75.8	-	-	-	-
Harmon [17]	Qwen-2.5-1.5B	MAR	0.76	-	0.41	-	58.9	87.6	1476.0	65.5	38.9	-	-	-	-	-	-	-
TA-TiTok [153]	-	Self-Distill.	0.55	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-
ILLUME+ [154]	Qwen-2.5-3B	Parallel	0.72	-	-	-	-	87.6	1414.0	80.8	44.3	40.3	73.3	74.2	-	-	67.2	69.9
UniToken [155]	Chameleon-7B	Parallel	0.63	-	-	-	-	-	-	71.1	32.8	-	69.9	68.7	38.5	46.1	75.7	-
SemHiTok [23]	Vicuna-1.5-7B	Parallel	-	-	-	-	61.7	85.5	1993.8	75.2	41.0	36.6	79.8	-	-	-	-	-
Show-o2 [16]	Qwen-2.5-7B	Parallel	0.76	86.14	-	-	63.1	-	1620.5	79.3	48.9	-	69.8	78.6	-	56.6	-	-
MANZANO [133]	Vicuna-13B	Parallel	-	-	-	-	-	-	-	83.4	57.8	-	76.0	86.0	73.3	-	86.3	84.4
TokLIP [14]	Qwen-2.5-7B	Cascade	-	-	-	-	57.3	85.2	1586.8	77.4	47.1	-	72.1	77.7	-	-	-	-
TUNA [13]	Qwen-2.5-7B	Cascade	0.90	86.76	-	-	63.9	-	1641.5	-	49.8	-	74.7	79.3	-	61.2	74.3	-
OpenVision3 [159]	Qwen-2.5-7B	Cascade	-	-	-	-	61.1	85.3	1679	-	-	-	66.0	-	-	-	-	-

Table 6. Comparison of unified tokenizers on multimodal generation and understanding. Methods are grouped by tokenizer strategy. For models with multiple variants, we report the best version in their paper.

Method	LLM Backbone	Tokenizer Strategy	Generation			Multimodal Understanding											TextRich
			GenEval	DPG-Bench	WISE	VQAv2	GQA	POPE	MME	MMB	MMMU	MMV	SEED	AI2D	MathV	MMS	OCRBench	TextVQA
Task-Specific Tokenizer (Single Tokenizer)
LWM [170]	LLaMA-2-7B	VQGAN	-	-	-	55.8	44.8	-	-	-	-	-	-	-	-	-	-	-
Transfusion [25]	LLaMA-2-7B	SD-VAE	0.63	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-
Show-o [27]	Phi-1.5-1.3B	MAGVITv2	0.53	67.27	0.28	69.4	58.0	80.0	1097.2	-	26.7	-	-	-	-	-	-	-
EMU3 [171]	8B from scratch	MoVQGAN	0.66	80.60	-	75.1	60.3	85.2	-	58.5	31.6	37.2	-	70.0	-	-	68.7	64.7
D-DiT [172]	SD3-2B	VAE	0.65	-	-	60.1	59.2	84.0	1124.7	-	-	-	-	-	-	-	-	-
Muddit [24]	Meissonic-1B	VQGAN	0.61	-	-	68.2	57.5	-	1107.4	28.4	27.6	-	-	-	-	-	-	-
MMaDA [26]	LLaDA-8B	MAGVITv2	0.63	69.97	0.67	76.7	61.3	86.1	1410.7	68.5	30.2	-	-	-	-	-	-	-
Lumina-DiMOO [173]	LLaDA-8B	VQGAN	0.88	86.04	-	-	-	87.4	1534.2	84.5	58.6	-	-	-	-	-	-	-
Task-Specific Tokenizer (Seperate Tokenizer)
Unified-IO 2 [9]	T5-XXL	VAE + ViT	-	-	-	77.0	-	-	-	-	-	-	-	-	-	-	-	-
Janus [10]	DeepSeek-LLM-1.3B	VQ + SigLIP	0.61	-	-	77.3	59.1	87.0	1338.0	69.4	30.5	34.3	63.7	-	-	-	-	-
JanusFlow [161]	DeepSeek-LLM-1.3B	VQ + SigLIP	0.63	80.09	-	79.8	60.3	88.0	1333.1	74.9	29.3	30.9	70.5	-	-	-	-	-
Janus-Pro [160]	DeepSeek-LLM-7B	VQ + SigLIP	0.80	84.19	-	-	62.0	87.4	1567.1	79.2	41.0	50.0	72.1	-	-	-	-	-
UniFluid [162]	Gemma-2	VAE + CLIP	0.59	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-
MindOmni [174]	QwenVL-2.5-7B	VAE + QwenViT	0.83	-	0.71	-	-	-	-	83.2	51.6	-	-	-	-	-	-	-
Skywork UniPic [175]	Qwen-2.5-7B	MAR + SigLIP2	0.86	85.50	-	-	-	-	-	-	-	-	-	-	-	-	-	-
BAGEL [11]	Qwen-2.5-7B	VAE + SigLIP2	0.82	-	0.70	-	-	-	2388.0	85.0	55.3	67.2	67.2	-	-	73.1	-	-
Unified Tokenizer (Single Encoder)
UniTok [131]	Llama-2-7B	C. L.	-	-	-	76.8	61.1	83.2	1448.0	-	-	33.9	-	-	-	-	-	-
ATOKEN [132]	SlowFast-LLaVA-1.5-7B	C. L.	0.65	-	-	-	-	-	-	-	48.7	-	-	81.2	61.2	-	74.5	-
Ming-Tok [12]	Ling-lite-16B-A3B	Distill.	0.85	-	-	-	-	-	2023.0	78.5	40.3	64.2	-	82.8	66.6	63.7	72.4	-
EMU3.5 [176]	-	Distill.	0.86	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-
EMU2 [139]	Llama-2-33B	Frozen VFMs	-	-	-	84.9	65.1	-	1450.0	65.1	34.1	48.5	62.8	-	-	-	-	66.6
VILA-U [140]	Llama-2-7B	C. L.	-	-	-	75.3	61.1	83.9	1336.0	-	-	27.7	-	-	-	-	-	60.8
QLIP [142]	Vicuna-1.5-7B	C. L.	0.48	78.17	-	78.3	61.8	86.1	1498.3	-	-	-	-	-	-	-	-	55.2
DualToken [143]	Qwen-2.5-3B	Self-Distill.	-	-	-	77.8	-	86.0	1489.2	70.9	38.6	32.5	70.2	-	46.5	-	-	-
BLIP-3o [177]	QwenVL-2.5-7B	Frozen VFMs	0.84	81.60	0.62	83.1	-	-	2329.7	83.5	50.6	66.6	77.5	-	-	-	-	-
UniLIP [15]	InternVL-3-2B	Self-Distill.	0.90	-	0.63	-	-	-	1636.0	80.7	48.7	62.2	75.0	78.6	-	-	-	-
UniFlow [146]	Qwen-2.5-7B	Self-Distill.	-	-	-	-	65.90	89.8	2063.0	83.5	-	-	-	-	-	-	-	81.6
VQRAE [149]	Qwen-2.5-7B	Self-Distill.	0.96	89.78	-	-	-	90.5	1746.8	85.1	61.6	-	77.0	84.8	-	-	-	80.6
PS-VAE [19]	-	Self-Distill.	0.76	83.62	-	-	-	-	-	-	-	-	-	-	-	-	-	-
Unified Tokenizer (Dual Encoder)
Muse-VL [22]	Qwen-2.5-32B	Parallel	0.53	-	-	-	-	-	-	81.8	50.1	-	71.0	79.9	55.9	56.7	-	-
TokenFlow [18]	Qwen-2.5-14B	Parallel	0.55	73.38	-	-	-	-	1922.2	76.8	43.2	48.2	72.6	75.8	-	-	-	-
Harmon [17]	Qwen-2.5-1.5B	MAR	0.76	-	0.41	-	58.9	87.6	1476.0	65.5	38.9	-	-	-	-	-	-	-
TA-TiTok [153]	-	Self-Distill.	0.55	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-
ILLUME+ [154]	Qwen-2.5-3B	Parallel	0.72	-	-	-	-	87.6	1414.0	80.8	44.3	40.3	73.3	74.2	-	-	67.2	69.9
UniToken [155]	Chameleon-7B	Parallel	0.63	-	-	-	-	-	-	71.1	32.8	-	69.9	68.7	38.5	46.1	75.7	-
SemHiTok [23]	Vicuna-1.5-7B	Parallel	-	-	-	-	61.7	85.5	1993.8	75.2	41.0	36.6	79.8	-	-	-	-	-
Show-o2 [16]	Qwen-2.5-7B	Parallel	0.76	86.14	-	-	63.1	-	1620.5	79.3	48.9	-	69.8	78.6	-	56.6	-	-
MANZANO [133]	Vicuna-13B	Parallel	-	-	-	-	-	-	-	83.4	57.8	-	76.0	86.0	73.3	-	86.3	84.4
TokLIP [14]	Qwen-2.5-7B	Cascade	-	-	-	-	57.3	85.2	1586.8	77.4	47.1	-	72.1	77.7	-	-	-	-
TUNA [13]	Qwen-2.5-7B	Cascade	0.90	86.76	-	-	63.9	-	1641.5	-	49.8	-	74.7	79.3	-	61.2	74.3	-
OpenVision3 [159]	Qwen-2.5-7B	Cascade	-	-	-	-	61.1	85.3	1679	-	-	-	66.0	-	-	-	-	-

Unified tokenizers, especially single-encoder designs, further improve generation quality. RAE [102] and RecTok [21] achieve gFID 1.13, surpassing both continuous (SD-VAE 1.26) and discrete baselines (IBQ [105] 2.05). Unified tokenizers are also more parameter-efficient. Several models (e.g., VA-VAE, AVFM, FAE) achieve high fidelity (gFID <1.40) with ∼675M parameters, whereas discrete models often require larger backbones (1.4B–2.1B) yet yield worse results. This indicates that unified tokenization provides more efficient feature representation and cross-modal alignment.

For multimodal generation, we report results on GenEval [187], DPG-Bench [188], and WISE [189]. Unified tokenizers significantly outperform task-specific tokenizers: for example, reconstruction-oriented methods such as Show-o achieve only 0.53 on GenEval, whereas unified models with semantic supervision perform substantially better. Among unified models, single-encoder designs achieve the best performance, with VQRAE [149] and UniLIP [15] reaching 0.96 and 0.90 on GenEval. Dual-encoder approaches generally perform slightly worse, although cascade designs such as TUNA [13] remain competitive and outperform parallel architectures like TokenFlow [18].

6. Challenges and Future Directions

Scaling of Unified Tokenizers. A central challenge is balancing high-level semantic representations for multimodal understanding with the fine-grained representations required for high-fidelity generation. Recent unified tokenizers attempt to narrow this semantic–fidelity gap through techniques such as semantic distillation and frequency-domain decomposition, but their effectiveness at scale remains largely unexplored. Systematic studies on tokenizer scaling are scarce [136], and most existing vision–language and generative models are still limited to fewer than 10B parameters. As a result, the benefits of unified tokenization have not yet been fully validated in large-scale multimodal systems. Future work should therefore investigate how unified tokenizers behave as model size, dataset scale, and training compute increase. In particular, it is important to determine whether unified tokenizers can consistently improve performance relative to task-specific baselines while preserving low-level visual fidelity as semantic abstraction strengthens.

Towards Omni-modal Unified Tokenizers. The emergence of world models and omni-modal systems introduces new requirements for tokenization. Instead of compressing a single modality, tokenizers must support unified semantic grounding, consistent spatiotemporal alignment, and efficient cross-modal interaction across modalities such as images, video, audio, and language. Early work such as AToken [132] has begun exploring unified tokenization frameworks, but research in this direction remains limited. Future work should extend unified tokenization to a broader range of modalities within a shared latent space. Such omni-modal tokenizers could enable scalable world learners that capture coherent spatiotemporal dynamics and rich cross-modal dependencies, facilitating stronger knowledge sharing across tasks and modalities.

Tokenizer-free Understanding and Generation. Recent studies have begun exploring tokenizer-free paradigms for multimodal understanding [190,191,192]. By removing standalone visual encoders, these approaches encourage a vision-centric information flow that strengthens cross-modal interactions and improves data scalability. For example, visual tokens may dominate attention during inference, enabling stronger visual–language alignment compared with modular architectures. A similar shift is occurring in image generation: JiT [193] directly models pixel-space generation without relying on pretrained tokenizers, preserving intrinsic low-dimensional structures of visual data. These developments suggest a broader direction toward self-contained architectures that reduce reliance on external tokenizers. Extending tokenizer-free designs to richer multimodal settings may further enable unified end-to-end understanding and generation.

Tokenizer with 3D-Awareness. Another emerging challenge is integrating geometric reasoning into visual tokenization. Current 3D understanding models [194,195,196] often excel at semantic reasoning but lack precise geometric grounding, while reconstruction approaches [197,198,199] capture detailed geometry but operate largely independently from semantic cognition. This separation creates a disconnect between high-level reasoning and low-level geometric representation. Future research should aim to unify these perspectives by developing tokenization frameworks that jointly encode semantic reasoning and geometric structure, enabling more comprehensive 3D scene understanding and generation.

Dynamic and Adaptive Tokenization. Most existing tokenizers rely on fixed compression rates, treating all visual regions equally and often introducing computational redundancy. In contrast, human perception allocates more resources to salient regions while processing peripheral information at lower resolution. Incorporating such adaptive mechanisms could improve both efficiency and representation quality. Recent work on 1D tokenizers [101,117,127,153,200,201,202,203,204] provides flexibility but may lose spatial or temporal structure. Approaches such as DCS-LDM [205] partially mitigate this issue through patch-level compression. However, token allocation is still largely determined by heuristics. Developing learnable importance estimators that dynamically allocate tokens based on content may be crucial for scaling tokenization to high-resolution imagery and long-form video.

From Visual Representation to World Modeling. Current visual tokenizers [44,58,136] primarily encode static appearance and semantic information while remaining largely physics-blind. As research moves toward general world models, tokenizers must capture temporal dynamics and causal relationships. Recent work such as V-JEPA2 [206] models latent temporal dynamics to learn physical regularities, while LAPA [207] represents visual changes as action tokens for vision–language–action systems. Building on these ideas, future world models may employ unified tokenizers as shared state-space representations that integrate perception, generation, and action. Such unified token sequences could allow a single architecture to model complex world dynamics and move beyond modular multimodal systems.

7. Conclusions

Visual tokenization has emerged as a key abstraction for modern vision and multimodal systems, enabling high-dimensional visual signals to be represented and processed within token-based architectures. In this survey, we present a comprehensive overview of visual tokenizers and organize a rapidly growing body of work into a unified framework. By distinguishing between semantic-oriented and reconstruction-oriented paradigms and tracing their evolution, we highlight how different design choices reflect distinct objectives, assumptions, and evaluation strategies.

With the rise of unified multimodal models, visual tokenization is increasingly expected to support both understanding and generation within a shared representation. We therefore review recent progress in unified tokenizers and analyze their strengths and limitations across diverse tasks and benchmarks. Our analysis highlights several key challenges, including balancing semantic abstraction with visual fidelity, efficiently scaling token representations, and designing evaluation protocols suited to modern multimodal systems. Visual tokenization is becoming an increasingly central component of future multimodal architectures. Advances in unified and adaptive tokenization may enable more scalable and general-purpose AI systems capable of perception, reasoning, and generation within a shared representational framework. We hope this survey serves as a useful reference for future research in visual tokenization and multimodal representation learning.