BYOL: Bring Your Own Language

• Bring Your Own Language (BYOL) is a paradigm that enables users to interact with computational systems and programming tools using their native language, eliminating the English-only barrier.
• BYOL utilizes systematic language resource classification and tailored pipelines, such as continual pretraining and supervised finetuning, to enhance model performance across low-resource and extreme-low-resource languages.
• In programming, BYOL is exemplified by UniversalPython, a transpiler that translates native-language syntax to canonical Python, ensuring high accuracy and minimal performance overhead.

Bring Your Own Language (BYOL) refers to frameworks and methodologies that enable users to interact with computational systems—particularly programming languages and LLMs—using their native or chosen human language, regardless of the language's resource level or digital footprint. The BYOL paradigm targets both democratization of programming (removing English as a barrier) and equitable LLM access for speakers of low-resource or extreme-low-resource languages. This approach encompasses technical solutions ranging from compilers that transpile non-English source code to English-centric programming languages, to multilingual LLM training pipelines that systematically expand model capabilities to under-represented languages. BYOL frameworks are motivated by the digital resource disparity affecting the vast majority of the world’s languages, the technical challenges of low-resource language modeling, and the need for scalable, language-aware tooling in both educational and industrial contexts (Bazaz et al., 10 Oct 2025, Zamir et al., 15 Jan 2026).

1. Language Resource Classification and Tiering

BYOL frameworks rely on systematic language classification to determine the most effective integration strategy for each target language. The core metric is digital corpus size, computed as the aggregate word count for each language ℓ in high-quality web-scale corpora, specifically FineWeb2. Speaker population is visualized for context but does not drive the pathway selection.

Four resource tiers are defined:

• Extreme-Low (EL): CorpusSize(ℓ) ≤ 5 × 10⁶ words
• Low (LR): 5 × 10⁶ < CorpusSize(ℓ) ≤ 2 × 10⁹ words
• Mid (MR): 2 × 10⁹ < CorpusSize(ℓ) ≤ 1 × 10¹¹ words
• High (HR): CorpusSize(ℓ) > 1 × 10¹¹ words

Routing is path-dependent: HR and MR languages are addressed by light task-specific finetuning within existing multilingual LLMs; LR languages undergo full-stack continual pretraining and supervised finetuning; EL languages are handled through translation-mediated pipelines (Zamir et al., 15 Jan 2026).

Tier	Corpus Size Range (words)	Integration Pathway
Extreme-Low	≤ 5 × 10⁶	Translation-mediated (BYOL-EL)
Low	(5 × 10⁶, 2 × 10⁹]	Data expansion, CPT, SFT (BYOL-LR)
Mid	(2 × 10⁹, 1 × 10¹¹]	Light finetuning
High	> 1 × 10¹¹	Light finetuning

2. BYOL-LR Pipeline: Data Refinement and Model Construction for Low-Resource Languages

For low-resource (LR) languages, BYOL deploys a comprehensive pipeline comprising corpus refinement, synthetic text generation, continual pretraining (CPT), and supervised finetuning (SFT):

1. Corpus Refinement: The initial step collects native-language data (FineWeb2) and supplements it with high-quality English educational corpora (FineWeb-Edu). Raw documents in ℓ are cleaned using a multilingual LLM (e.g., Azure GPT-5), which removes non-ℓ content, corrects grammar and punctuation, expands on-topic sections, and excises toxic material.
2. Synthetic Text Generation: The best available machine translation (MT) engine for ℓ, identified through round-trip translation scoring on a multi-domain English dataset, translates FineWeb-Edu into ℓ. Synthetic and native texts are mixed with refined English content.

The round-trip translation score (RTTScore) is:

$$RTTScore(T) = \frac{1}{|D|} \sum_{d \in D} \frac{1}{N_d} \sum_{i=1}^{N_d} M\left(s_i^{(d)}, T_{\ell \rightarrow en}\left(T_{en \rightarrow \ell}(s_i^{(d)})\right)\right)$$

where $M$ is a text similarity metric (e.g., sacreBLEU, chrF++, embedding cosine).

1. Continual Pretraining (CPT): The training corpus consists of equal parts refined native ℓ, synthetic ℓ, and refined English, with token counts balanced (e.g., ≈433M tokens for Chichewa). Models are optimized using causal LM loss $L = -\sum_t \log P(x_t|x_{<t};\theta)$ with AdamW.
2. Supervised Finetuning (SFT): Instruction data includes native-language samples, machine-translated pairs from high-resource languages, and cross-lingual English for anchoring. Total SFT datasets reach up to ~480M tokens.
3. Model Merging: Trained ℓ-expert, generalist pretraining (G_PT), and general instruct-tuned (G_IT) models are combined via a linear merge in parameter space:

$$M(\alpha, \beta) = G_{PT} + \alpha (G_{IT} - G_{PT}) + \beta (E_{\ell} - G_{PT}), \quad \alpha+\beta=1$$

Sweeping $\lambda \in [0,1]$, typically $\lambda \approx 0.6$–$0.7$ yields best bilingual performance, preserving English functionality and safety (Zamir et al., 15 Jan 2026).

3. BYOL-EL Pathway: Translate-Test Paradigm for Extreme-Low-Resource Languages

For languages lacking sufficient digital text (EL tier), BYOL employs a translation-mediated access framework:

1. Machine Translation System Construction: Parallel data sources (e.g., Nunavut Hansard for Inuktitut) are expanded with automatic sentence alignment and back-translation. An NMT is trained with 9 encoder/decoder layers (d_model=512, 8 heads), using Adam with Noam scheduler.
2. Evaluation: The in-house NMT system yields substantial BLEU improvements over commercial MT engines (e.g., +3.64 BLEU in Inuktitut→English, +4.31 BLEU in English→Inuktitut).
3. Translation-Mediated LLM Access: Downstream tasks (e.g., Global MMLU-Lite, translated into EL languages) are run by translating EL prompts to English, querying an English-centric LLM, and back-translating responses. This approach recovers up to 14 percentage points of accuracy compared to direct EL input, enabling practical LLM usage in the absence of sufficient language-specific training data (Zamir et al., 15 Jan 2026).

4. BYOL in Programming: UniversalPython and Multilingual Syntax

In programming, BYOL is exemplified by the UniversalPython transpiler, which allows users to write Python code using native-language keywords, operators, and numerals. UniversalPython functions as a PLY-based source-to-source compiler that maps native-script source code (e.g., Urdu, Hindi, Chinese) to canonical Python, supporting:

• YAML-defined bidirectional dictionaries (keyword and digit mapping)
• Unicode preprocessing and optional transliteration
• AST-preserving parsing, ensuring round-trip semantic fidelity
• Tooling integration, such as Jupyter/IPython kernels and web UIs
• Bidirectional conversion to enable editing and execution in either language

Functional correctness is demonstrated by 98% pass rates on canonical algorithm benchmarks; performance overhead is minimal, with some cases showing faster execution due to in-memory parsing optimizations. Coverage extends to multiple language variants, and user studies indicate that after short exposure, the majority of participants can successfully program using native-language syntax (Bazaz et al., 10 Oct 2025).

5. Evaluation, Metrics, and Empirical Results

• LLMs (BYOL Framework):
  • BYOL-nyA (Chichewa, 4B) achieved 51.82% average on 12 benchmarks, outperforming Gemma-3 (4B PT, 39.95%) by +11.87 points.
  • Merged instruction-tuned BYOL models (e.g., BYOL-nya 4B-M) outperform larger baselines (Apertus 8B Inst, Gemma-3 27B IT) and win ≈60–65% of LLM-as-judge comparisons against much larger models.
  • Inuktitut EL MT system enables LLM translation chains that recover ~14 percentage points of accuracy on MMLU-Lite compared to direct input.
• Programming (UniversalPython):
  • 98% round-trip correctness across 110 Python algorithm benchmarks
  • Minimal runtime penalty overall; in some scripting use-cases, overhead is imperceptible
  • Multi-language variants demonstrated (Urdu, Chinese, Hindi) with bidirectional translation
  • User study showed 80% correct submissions from first-time native-language Python users after brief documentation review (Bazaz et al., 10 Oct 2025, Zamir et al., 15 Jan 2026)

6. Limitations, Scalability, and Prospective Advancements

Limitations of BYOL approaches include:

• For LLMs: Residual dependency on English-centric documentation and third-party libraries even when code or interface is native; variable translation quality for low-resource languages; inability to fully address grammar/plurality mismatches between language orders (SOV/SVO).
• For programming: Multi-word keywords can conflict with spacing tokenization; program comprehension may still require knowledge of English APIs; current pipelines do not address multi-word lexical ambiguities or grammatical structure divergences in all target languages.

Planned enhancements are focused on:

• Version-controlled dictionary/plugin packs for major language or library updates
• Automated language interfaces for third-party libraries and docstrings
• Crowdsourced lexical mapping and human verification
• Deeper regional user studies for metric-driven UX improvements
• Expanded IDE/REPL integration to cover the full software/tooling ecosystem (Bazaz et al., 10 Oct 2025, Zamir et al., 15 Jan 2026)

7. Significance and Broader Impact

The BYOL paradigm addresses a major equity gap in both LLM and programming language accessibility by removing English as a de facto requirement. By enabling scalable, data-efficient pipelines for adding new languages, and providing tooling for writing and executing code in virtually any human language, BYOL frameworks lower the barrier for inclusion of minority, low-resource, and extreme-low-resource languages in modern computational infrastructure. These developments facilitate broader participation in the digital economy, preserve linguistic diversity in technology, and lay groundwork for future research on cross-linguistic model alignment and fair evaluation in NLP and language-centric software systems (Bazaz et al., 10 Oct 2025, Zamir et al., 15 Jan 2026).