Ask a sharp question in English, and you’ll likely get a sharp answer back. Pose the same question in Swahili or Icelandic, and the reply can feel oddly vague, sometimes completely off the mark. This isn’t a random quirk. It’s a predictable outcome of how these systems are fed, built, and tested. To see why, we need to look at the data diet, the hidden assumptions baked into the architecture, and the ways we measure—or fail to measure—success.
The Data Diet: What Goes In Shapes What Comes Out
Training data is the single biggest lever on performance, and the web’s linguistic landscape is anything but even. English dominates, trailed by a handful of other high-resource languages—Chinese, Spanish, French, German, Russian. For most of the world’s roughly 7,000 languages, the available digital text is tiny. A typical large training set might include over 100 billion tokens of English, while Yoruba or Pashto gets a few million tokens if it’s lucky. The model’s internal representations—the vector spaces where meaning gets encoded—end up heavily skewed toward English syntax, semantics, and even cultural defaults. When a low-resource language shows up, the model processes it through that English-tuned lens, and the output wobbles: grammar slips, meaning drifts, and the system often falls back on English-like completions.
But volume isn’t the whole story. Quality and diversity matter just as much. High-resource languages feast on curated material: books, academic papers, professionally edited news, richly annotated corpora. Low-resource languages often survive on web scraps—boilerplate text, machine-translated pages, messy user-generated content. A model trained on stilted, translated religious texts for a particular language will spit out archaic-sounding prose even when you ask it something casual. The diet shapes the voice.
Then there’s tokenization, the step where raw text gets chopped into digestible pieces. Tokenizers are usually tuned for the languages that dominate the training set. English, with its tidy word boundaries, tokenizes cleanly. But a morphologically dense language like Finnish or Turkish gets shredded into many subword fragments. The model has to process a longer sequence to capture the same meaning, which strains its ability to track long-range dependencies and adds computational overhead. The result: lower-quality output for languages that don’t fit the tokenizer’s implicit assumptions.
Linguistic Distance and the Curse of Shared Parameters
Even when two languages have comparable data volumes, they aren’t equally easy for a single model to learn. Word order, morphological richness, writing systems, syntactic conventions—all vary wildly. A model that shares all its parameters across languages must settle on a compromise configuration that works “well enough” for everyone. That compromise is rarely fair. The so-called curse of multilinguality kicks in: as you add more languages, the model’s fixed capacity gets stretched thinner, and performance on individual languages—especially those typologically distant from the majority—degrades.
English and French, for instance, share a lot of structural DNA thanks to their Indo-European roots and centuries of contact. A model trained mostly on these two transfers knowledge between them fairly smoothly. Throw Japanese into the mix, with its subject-object-verb order, particle-based grammar, and mixed scripts, and the shared parameters start to groan. You might get Japanese output with English-like clause ordering, or honorifics that feel randomly applied. The model hasn’t learned the cultural logic behind the forms; it’s just pattern-matching across incompatible systems.
This interference goes beyond syntax. Politeness strategies, discourse markers, ways of expressing uncertainty—these are deeply cultural. A model soaked in English norms of directness can come across as rude or tone-deaf in languages where indirectness signals respect. Standard accuracy metrics rarely catch these mismatches, but they shape how real people experience the system.
Evaluation Gaps: Measuring What We Can, Missing What Matters
We can only improve what we can measure, and measurement is another source of unevenness. Most benchmarks for language understanding and generation originate in English, designed by English-speaking researchers. When those benchmarks get translated or adapted, they often carry hidden baggage. A reading comprehension test built on English Wikipedia articles rewards models that have gorged on English data. Translate the test into Thai, and the underlying knowledge—historical figures, cultural references, scientific framing—still tilts Anglophone.
The metrics themselves can mislead. Automated scores like BLEU or ROUGE compare generated text against reference translations, but they correlate poorly with human judgment, especially for languages with rich morphology or flexible word order. A model can ace a Hindi translation task by producing grammatically correct but semantically empty sentences that superficially match the reference. Human evaluation is more trustworthy, but it’s expensive and hard to scale across dozens of languages. So we’re often flying blind in low-resource settings.
This creates a self-reinforcing loop: we can’t measure performance well in low-resource languages, so we don’t prioritize improving it; because we don’t prioritize it, data and modeling innovations stay focused on high-resource languages; and because the models are optimized for those languages, the evaluation tools keep being designed around them. Breaking the cycle takes deliberate work—building benchmarks that are culturally and linguistically grounded, and involving native speakers from the start.
Architectural Constraints and the Capacity Bottleneck
Data and evaluation aren’t the only bottlenecks. The architecture itself imposes hard limits. Most current designs rest on the Transformer, which uses self-attention to process sequences. It’s powerful, but its capacity is fixed by the number of parameters. When a single model juggles 100 languages, those parameters must encode the syntax and semantics of each language plus the cross-lingual mappings that enable translation and transfer. It’s a zero-sum game: giving more representational space to one language takes it away from others.
Researchers have tried workarounds. One is adding small language-specific adapter modules that sit alongside the shared backbone. Another is conditioning the model on a language identifier token, nudging it toward the right linguistic mode. These help, but the shared backbone still dominates, and the internal representations remain heavily colored by the high-resource languages that dominated training.
Then there’s negative transfer, where knowledge from one language actively hurts performance in another. If the model learns that adjectives usually come before nouns (as in English), it may stumble on languages where adjectives follow nouns (Spanish, Arabic). The model has to learn both orders and when to apply which rule—a disambiguation problem that gets harder with every new language added.
The Resource Gap: A Self-Perpetuating Cycle
Uneven performance isn’t just a technical curiosity. It mirrors and deepens real-world inequalities. Languages with large speaker populations and strong digital footprints—English, Mandarin, Spanish—pull in investment for data creation, tooling, and research. Languages with fewer speakers or less economic clout get left behind. The result is a digital divide: speakers of low-resource languages get inferior technology, which limits the technology’s usefulness in their communities, which reduces the incentive to create more data or build better tools. Round and round it goes.
Breaking this cycle takes intentional effort. It means funding data collection for underrepresented languages—not just translation, but original, high-quality content. It means building evaluation benchmarks that reflect what speakers actually need: medical advice, legal information, educational material. And it means designing models that can adapt to new languages efficiently, without massive retraining or sacrificing performance on existing ones.
There are promising directions. Models that exploit shared features across related languages—say, the Romance or Bantu families—can boost performance for low-resource members by borrowing knowledge from their higher-resource relatives. Techniques like meta-learning and few-shot adaptation can help models pick up new languages from small datasets. But these are partial fixes. The fundamental challenge remains the vast imbalance in the world’s digital linguistic landscape.
Frequently Asked Questions
Why do some languages perform worse even when they have large speaker populations?
Speaker count doesn’t automatically translate to digital presence. Hindi and Bengali each have hundreds of millions of speakers, but their high-quality digital text is relatively limited compared to English. Economics, internet penetration, and historical investment in language technology all play a role. A language can be widely spoken yet digitally scarce if its speakers primarily use another language online or if there’s little institutional support for creating digital content in that language.
Can a model be equally good at all languages if it is simply made larger?
Scaling up model size helps to a point, but it doesn’t fix the underlying data imbalance. A larger model can memorize more patterns, but if the training data for a low-resource language is noisy or thin, the model will still struggle to generalize correctly. Bigger models are also more expensive to train and run, which may not be justifiable for languages with smaller user bases. Efficiency and data quality often matter more than raw parameter count.
How can users tell if a model is performing poorly in their language?
Probe it with tasks that demand deep linguistic or cultural knowledge: ask it to complete a proverb, explain a local custom, or generate a grammatically complex sentence. If the output feels generic, carries English-like structures, or misses culturally specific nuances, that’s a red flag. Systematic evaluation requires curated test sets designed by native speakers, and those are still rare for many languages.
