OCR Is Mostly Language Priors Wearing a Vision Hat: Lessons from GlotOCR Bench

Introduction

Optical character recognition is one of the oldest tasks in pattern recognition, and the conventional wisdom holds that it is fundamentally a vision problem. You take an image of text, you decode the shapes into characters, you output a string. Vision in, text out. The recent paper GlotOCR Bench: OCR Models Still Struggle Beyond a Handful of Unicode Scripts by Kargaran, Nikeghbal, Diesner, Yvon, and Schütze challenges this framing in a way that deserves attention.

The authors built a benchmark spanning 158 Unicode scripts, rendered from real multilingual texts, and evaluated a wide suite of open-weight and proprietary vision-language models. The headline result is uncomfortable. Every model evaluated performs well on Latin, degrades on mid-resource scripts such as Arabic, Cyrillic, and Devanagari, and effectively collapses on the remaining 148 scripts. Those 148 scripts represent 94 percent of the benchmark, and no model exceeds 10 percent Acc@5 on them. The best result, 7.7 percent, comes from Gemini 3.1 Flash-Lite, dots.ocr, and dots.mocr. Most models score below 1 percent.

This is not a story about a few percentage points of headroom. It is a story about a near-total failure mode that has been hiding in plain sight, masked by the narrow script coverage of existing benchmarks.

What the Benchmark Actually Measures

The methodological care in GlotOCR Bench is worth understanding, because the validity of the central claim depends on it. The risk with any multilingual OCR benchmark is that you measure rendering bugs rather than model failures. If your fonts shape text incorrectly, or your rasterizer mangles complex scripts, then poor model scores tell you nothing about the model.

The authors address this directly. Images are rendered using fonts from the Google Fonts repository, shaped with HarfBuzz, and rasterized with FreeType, the same production stack used by browsers and operating systems. Both left-to-right and right-to-left scripts are handled with proper bidirectional logic. Crucially, samples were manually reviewed to verify correct rendering across all scripts. They also include both clean and degraded image variants, which separates the question of recognition under ideal conditions from recognition under noise.

The evaluation uses two acceptance metrics, Acc@0 and Acc@5, alongside character error rate, stratified by script and resource tier. Acc@5 is the more forgiving metric, accepting outputs within a small error tolerance, and the fact that scores still collapse under Acc@5 makes the result harder to dismiss as a strict-matching artifact.

The resource tiering is the conceptual backbone of the paper. The authors group scripts into:

• High-resource: 1 script, Latin.
• Mid-resource: 9 scripts, including Arabic, Cyrillic, and Devanagari.
• Low-resource: 148 scripts.

Plotted against these tiers, performance follows a cliff. Gemini 3.1 Flash-Lite scores 95.3 percent on Latin, 82.7 percent on mid-resource scripts, and 7.7 percent on low-resource scripts. The shape of this curve, repeated across fourteen models, is the actual finding.

The Diagnostic Signal: Hallucination, Not Noise

The most analytically interesting part of the paper is not the failure itself but the character of the failure. When a model is given a script it does not know, it does not refuse, and it does not output gibberish at random. Instead it produces fluent-looking text in a script it does know. A Gujarati image yields Devanagari output. A Thaana image yields Arabic output.

This is the tell. If OCR were purely a visual decoding problem, a model encountering unfamiliar glyphs would either fail to segment them or produce near-random predictions. Instead, the models map the visual input onto the nearest script in their training distribution. They recognize that the image contains text, they recognize approximately what visual neighborhood the glyphs occupy, and then they reach for the closest writing system they have seen during pretraining.

The authors interpret this as evidence that performance tracks script-level pretraining coverage rather than visual difficulty. I think this is the correct reading, and I would push it slightly further. Gujarati and Devanagari are visually related Brahmic scripts; Thaana and Arabic are both abjad-influenced and share a right-to-left orientation. The hallucinations are not arbitrary. They land on scripts that are both visually adjacent and well-represented in the language model's text pretraining. The vision encoder is doing enough work to place the input in roughly the right region of script space, but the language model decoder collapses the prediction onto whatever it can actually generate.

In other words, the bottleneck is generation capacity, not perception. A model cannot output character sequences it never learned to model, regardless of how clearly it perceives them. This reframes OCR for low-resource scripts as a coverage problem in the text pretraining corpus first and a vision problem second.

Connecting to the Broader Field

This result fits a pattern that has been emerging across multimodal research. The dominant vision-language model architecture pairs a vision encoder with a pretrained language model decoder, and the language model's prior dominates output behavior far more than practitioners often assume. We have seen analogous effects in image captioning, where models describe objects consistent with linguistic priors rather than pixel evidence, and in document understanding, where models confidently fabricate plausible field values.

GlotOCR Bench also exposes a blind spot in existing evaluation culture. The dominant benchmarks, OCRBench, OCRBench v2, CC-OCR, and OmniDocBench, concentrate on Latin, CJK, and a handful of mid-resource scripts. Even work explicitly aimed at multilingual OCR, such as the XDocParse benchmark covering 126 languages, focuses on languages rather than scripts. This distinction matters enormously. Hundreds of languages share the Latin script, so a language-counted benchmark can look diverse while testing almost no script diversity at all. By making script the primary axis, GlotOCR Bench reveals that the field has been optimizing within a small island of writing systems while reporting progress as if it were general.

The practical stakes are real. The authors note that scripts such as Ethiopic, Khmer, and Sinhala serve tens of millions of people, while Armenian, Tibetan, and Myanmar anchor entire national literatures. Digitization of documents in these scripts depends on OCR, and digitized text is itself a major potential source of training data for low-resource languages. There is a circularity here that is easy to miss. Reliable OCR is a prerequisite for building the corpora that would improve OCR, and the current failure breaks that loop before it starts.

Limitations and Open Questions

A few caveats temper the conclusions. The benchmark is rendered rather than scanned, so it isolates the script-recognition question but does not capture the full complexity of historical documents, degraded scans, handwriting, or layout. The degraded variants help, but synthetic degradation is not equivalent to the artifacts of a century-old manuscript. The font selection also constrains the visual diversity within each script; real-world typefaces vary far more than a curated Google Fonts subset.

There is also an interpretive question the paper raises but cannot fully resolve. If the failure is driven by text pretraining coverage, then the obvious remedy is to add low-resource script text to the language model's pretraining mix. But it is unclear how much text is needed, and whether the vision encoder itself has sufficient capacity to discriminate fine-grained glyphs in scripts with large character inventories once the decoder can express them. Disentangling encoder capacity from decoder coverage is the natural follow-up study, and it would benefit from controlled experiments that vary pretraining script exposure while holding the vision stack fixed.

Conclusion

GlotOCR Bench makes a clean and consequential argument. Across 158 Unicode scripts, even frontier models fail to generalize past roughly thirty, most open models succeed on fewer than ten, and the strongest system averages only 61.9 percent Acc@5 across resource tiers. The decisive evidence is behavioral: on unfamiliar scripts models hallucinate characters from scripts they already know, which points to language model priors rather than visual difficulty as the binding constraint.

The framing that OCR is a vision problem has quietly outlived its accuracy. For a small set of high-resource scripts, the vision-language pipeline works well enough that the language prior is invisible. Step outside that set and the prior becomes the whole story. The open question now is whether closing the gap requires better vision, broader text pretraining, or an architecture that can transcribe scripts it has never been taught to generate. My expectation is that the cheapest gains will come from text pretraining coverage, but the most interesting science lies in building OCR systems that can decode genuinely novel symbol sets without leaning on what they already know.