Byte-Pair Encoding (BPE) Algorithm

• Byte-Pair Encoding (BPE) is a frequency-driven, greedy algorithm that iteratively merges symbol pairs to form a variable-length subword vocabulary for NLP tasks.
• It is widely used in machine translation and language model pretraining, enabling open-vocabulary modeling and efficient text compression across various languages.
• Recent extensions like BatchBPE, Parity-Aware BPE, and AdaptBPE address traditional limitations by improving speed, fairness, and adaptability in tokenization.

Byte-Pair Encoding (BPE) is a frequency-driven, greedy algorithm originally designed as a data compression method and now established as a central subword tokenization framework in NLP. BPE iteratively merges the most frequent adjacent symbol pairs in a corpus, inducing a variable-length subword vocabulary that achieves effective compression, enables open-vocabulary modeling, and demonstrates robustness across diverse languages and scripts. The algorithm’s theoretical characteristics and empirical efficacy underpin its wide adoption in machine translation, language modeling, and LLM pretraining.

1. BPE Algorithmic Foundation and Core Procedure

BPE begins by representing the input corpus as a sequence over a base alphabet (typically bytes or Unicode codepoints) and proceeds through a predefined number of merge steps, each identifying and replacing the most frequent adjacent symbol pair. This process results in an evolving token inventory that spans a continuum between atomic characters and frequent multi-character substrings or words.

The canonical BPE merging loop can be formalized as follows (Kunchukuttan et al., 2016, Kozma et al., 2024):

• Initialization: Let $C$ be the training corpus, segmented into atomic symbols and explicit word-boundary markers as needed. The initial vocabulary $V_0$ comprises all distinct symbols plus any special markers.
• Iterative Merge Procedure (for $t = 1$ to $T$ merges):
  • Compute the frequency $f_t(xy)$ of every consecutive symbol pair $xy$ in the corpus.
  • Select the most frequent pair $(x^*, y^*) = \arg\max_{(x,y)} f_t(xy)$.
  • Add the merged symbol $z = x^* \circ y^*$ to the vocabulary, $V_t = V_{t-1} \cup \{z\}$.
  • Re-encode the corpus, replacing every occurrence of $x^* y^*$ with $z$.
• The procedure terminates upon reaching the merge budget $T$, producing a merge list and final vocabulary $V_T$.

Encoding new tokens involves greedily matching the longest symbol (subword) at each position with respect to the learned $V_T$.

2. Theoretical Analysis and Approximation Guarantees

BPE is a greedy approximation to a combinatorial optimization problem: maximize the compression utility (token count reduction) over all admissible sequences of $k$ merges. The optimization is APX-complete (Kozma et al., 2024), precluding efficient polynomial-time approximation schemes. However, BPE’s greedy approach provably attains a constant-factor approximation: for any input, the compression achieved is at least $0.333$ of the optimum and at most $0.625$ in the worst case (Kozma et al., 2024). Submodularity analysis provides a data-dependent tighter bound, showing the greedy BPE achieves at least a $(1/\sigma)(1-e^{-\sigma})$ approximation, with worst-case empirical lower bound $\approx 0.37$ (Zouhar et al., 2023). The critical property is that the BPE merge objective is sequence-submodular: the incremental gain of a merge diminishes as merges accumulate, justifying the greedy selection at each step.

BPE can be realized with efficient data structures for practical scalability. A doubly-linked list per token sequence and a max-heap indexed by pair positions yield $O(N \log M)$ total runtime for $N$-length input and $M$ merges (Zouhar et al., 2023).

3. Algorithmic Extensions and Variants

Research has yielded numerous practical and theoretical BPE extensions to address known limitations:

• BatchBPE: Safe parallelization allows batching of hundreds of merges per iteration by ensuring token pairs merged in a batch do not overlap in position, drastically reducing training time and memory without changing the final vocabulary or encoded text length beyond negligible differences (Morgan, 2024).
• Parity-Aware BPE: Modifies the merge criterion for multilingual corpora by maximizing compression gain for the currently worst-compressed language at each step. This eliminates tokenization length disparities across languages, reducing the Gini coefficient of token-cost variance (e.g., from 0.064 to 0.011) with negligible sacrifice in overall compression or downstream LM performance (Foroutan et al., 6 Aug 2025).
• Scaffold-BPE: Augments BPE to dynamically identify and exclude scaffold tokens—subwords serving only as transient composition units for longer tokens but infrequently appearing independently. Scaffold tokens are removed from the final vocabulary during encoding, promoting a more uniform token frequency distribution and improving model learning dynamics (Lian et al., 2024).
• AdaptBPE: Post-training adaptation of BPE-vocabularies replaces low-utility tokens with more domain- or language-relevant ones, optimizing for frequency on adaptation corpora while strictly maintaining the merge-dependency constraints. This methodology achieves improved compression utility and narrower inference outputs without retraining LLMs (Liyanage et al., 29 Jan 2026).
• BoundlessBPE: Overcomes the pre-tokenization barrier by allowing merges across pretoken (word) boundaries. This produces superwords (concatenations of entire words or substrings), yielding more uniform token frequency distributions, notably higher vocabulary utilization (up to 99%) and improved Rényi efficiency while enhancing compression by 19.7% in bytes per token (Schmidt et al., 31 Mar 2025).
• Dictionary Pruning and Multiscale: Dictionaries may be dynamically pruned, excising low-frequency multi-character tokens in favor of more competitive ones to cap vocabulary size and focus modeling capacity on frequent patterns (Merriënboer et al., 2017).

4. Linguistic Independence and Empirical Performance

Unlike orthographic syllable or morpheme-based segmentations, BPE does not depend on language-specific rules and operates uniformly across all writing systems: alphabetic, abugida, abjad, logographic, or syllabic. This script-agnostic approach ensures broad applicability (Kunchukuttan et al., 2016).

Empirical studies across 16 language pairs and 10 writing systems show BPE subword units outperform word, morpheme, and orthographic syllable units for translation and modeling tasks. BLEU improvements for BPE reach up to 18% over word-level and average +2.6%, with maxima up to 11% over orthographic syllables. Gains are especially pronounced in morphologically rich languages (Kunchukuttan et al., 2016). In large-scale settings, BPE remains robust with aggressive merge budgets (e.g., 30k–60k merges in NMT), and hyperparameter $T$ (number of merges) controls subword granularity.

5. Downstream Applications and Pipeline Integration

BPE and its derivatives function as foundational tokenization stages in multiple NLP pipelines:

• Statistical Machine Translation (SMT): BPE units serve as translation atomics, supporting monotonic decoding and robust LM construction; subwords are recomposed into original surface forms via simple marker-based desegmentation (Kunchukuttan et al., 2016).
• LLMs: BPE-trained vocabularies underpin LLMs and neural LLMs, supporting efficient, open-vocabulary sequence modeling and mitigating out-of-vocabulary issues. Scaffold-BPE and domain-adaptive approaches further optimize training data representation for downstream generation and classification (Lian et al., 2024, Liyanage et al., 29 Jan 2026).
• Multilingual and Domain-Specific Tokenizers: Parity-aware and adaptation-based variants enable fair, efficient, and equitable token allocation across heterogeneous corpora, supporting cross-lingual robustness and domain specialist deployment (Foroutan et al., 6 Aug 2025, Liyanage et al., 29 Jan 2026).

Practical implementations exploit unique-chunk frequency mappings, batch-merge scheduling, and dynamic memory-efficient structures for scalable, hardware-constrained settings (Morgan, 2024).

6. Limitations, Controversies, and Continuing Research

BPE exhibits non-optimality in the combinatorial sense but remains close to optimal for natural text. Notable trade-offs and challenges include:

• Pre-tokenization Constraint: Standard BPE's reliance on fixed token boundaries induces heavy-tailed distributions, necessitating BoundlessBPE and related innovations to flatten token frequency and raise vocabulary utilization (Schmidt et al., 31 Mar 2025).
• Learning Imbalance: Scaffold tokens in unmodified BPE may yield highly skewed update frequencies during model training, impairing embedding learning efficacy (Lian et al., 2024).
• Cross-Lingual Parity: Standard BPE under-allocates tokens to low-resource languages in multilingual setups, amplifying representation disparities unless explicitly addressed by parity-aware objectives (Foroutan et al., 6 Aug 2025).
• Computational Barriers: The APX-completeness of the underlying OPE/OMS problem precludes polynomial-time solutions for arbitrary approximation factors (Kozma et al., 2024).

Ongoing research focuses on theoretical approximation improvement, adaptive or hybridized merge criteria, and integration of semantic or syntactic constraints into the merge process.

7. Summary Table: Classical and Modern BPE Algorithms

Variant	Core Modification	Main Benefit	Source
Classical BPE	Greedy merges by freq	Compression, subword OOV handling	(Kunchukuttan et al., 2016, Kozma et al., 2024)
BatchBPE	Non-overlapping batch	Order-of-magnitude speedup in vocab training	(Morgan, 2024)
Parity-aware BPE	Max-min per-language	Cross-lingual equitability	(Foroutan et al., 6 Aug 2025)
Scaffold-BPE	Scaffold token removal	More uniform frequency, robust embeddings	(Lian et al., 2024)
AdaptBPE	Post-hoc vocab swap	Domain/language specialization	(Liyanage et al., 29 Jan 2026)
BoundlessBPE	Cross-pretoken merges	Uniformity, increased compression	(Schmidt et al., 31 Mar 2025)

BPE’s contemporary success lies in the synergy of simple, greedy optimization with robust practical performance, hardware-friendly runtime, and adaptability to diverse linguistic and application domains. Ongoing refinements continually address its theoretical and empirical limitations, ensuring its centrality in modern NLP workflows.