OXR: 1.3B Open-Source Document Parsing Model Tops Three Major Benchmarks

Document parsing has always been the dirty work in RAG and data processing pipelines. Tables, formulas, and chemical structures in scanned documents often require stitching together multiple models just to get by. Recently, a new option has emerged in the open-source community: OXR, an open-weight model with only 1.3B parameters, which the team claims has simultaneously taken first place on three mainstream document parsing benchmarks.

Model Capabilities: 13 Element Types, Covering Complex Layouts

OXR was developed by the SoMarkAI team, with the goal of converting PDFs and document images directly into Markdown or JSON with layout coordinates. It supports recognizing 13 element types and outputting bounding boxes, including tables, formulas, chemical equations, chemical structure diagrams, and code blocks.

What really sets it apart is its handling of complex layouts. The scenarios officially listed include A3 exam papers, newspapers, vertical text, and handwriting—exactly the areas where traditional OCR pipelines are most likely to break down. Most open-source parsers perform reasonably well on standard documents but fall apart the moment they encounter multi-column newspapers or handwritten annotations. OXR makes this a selling point, suggesting the team has invested effort in training data coverage.

RAG (Retrieval-Augmented Generation) refers to retrieving relevant document fragments from an external knowledge base as context before a generative model answers, thereby reducing hallucinations and improving answer timeliness and traceability. Its data entry points are typically unstructured documents such as PDFs, scans, and web pages, so document parsing quality directly determines whether retrieved fragments are clean and usable. Tables being chopped up, formulas turned into garbled text, and multi-column layouts being read out of order all pollute the vector database and lead to inaccurate recall. The value of dedicated parsing models like OXR lies precisely in converting dirty documents into clearly structured Markdown or coordinate-annotated JSON, providing reliable input for subsequent chunking, embedding, and retrieval.

Benchmark Results: First Place on Three Leaderboards Simultaneously

The official data (snapshot date October 5, 2026; competitor scores taken from published papers, model cards, and official leaderboards, not re-run):

• olmOCR-Bench: OXR-1.0 87.84, second place Infinity-Parser2-Pro 87.60
• OmniDocBench v1.6: OXR-1.0 97.18, second place TeleOCR 96.91
• DocParsingBench: OXR-1.0 87.76, second place PaddleOCR-VL-1.6 85.17

Leading on all three leaderboards, but the margins deserve closer scrutiny. On olmOCR-Bench the gap with second place is only 0.24 points, and on OmniDocBench it's 0.27 points—neck and neck. On DocParsingBench the lead is about 2.6 points, which is relatively more significant. It's worth noting that these competitor scores were taken by the team from public sources, and the testing conditions may not be entirely consistent, so some leeway should be retained when making horizontal comparisons.

olmOCR-Bench is a document OCR evaluation benchmark launched by AI2 (Allen Institute for AI), built on real PDFs and covering diverse layouts including tables, formulas, handwriting, and multi-column text. Its scoring examines both text accuracy and reading order, making it a commonly used comparison set for current open-source document parsing models. OmniDocBench is a comprehensive benchmark for full-scenario document parsing, covering multiple document types and element categories, and has iterated to versions such as v1.6. Because each leaderboard differs in page sources, scoring scripts, and element weights, the same model's relative ranking may vary across leaderboards. Direct score comparisons across leaderboards are of limited value; one should focus on rankings within the same leaderboard.

Speed: 100 Pages in 101 Seconds

Beyond accuracy, the team also emphasizes a speed advantage: ranked first among open-source document parsing models.

The test method placed all 21 models from the three leaderboards on the same set of 100 OmniDocBench pages, each running on a single RTX PRO 6000. OXR's end-to-end processing (including layout analysis, recognition, and reading order) of 100 pages took 101 seconds, roughly 1 page per second; the next fastest, OvisOCR2, took 135 seconds.

This test design is fairly restrained—fixed page set, fixed hardware, full-pipeline timing—which is more credible than reporting only single-model inference time. The complete table and test details are in the repository's docs/benchmark.md.

Architecture Approach: Pluggable Layout Analysis

There are two engineering design points worth noting in OXR.

First, the RSI post-training loop. The team uses recursive self-improvement to automatically convert parsing errors and uncertain results into targeted training data, without manual annotation. This means the model's iteration speed can escape the annotation bottleneck, which is the basis for their claim of "faster improvement."

Second, layout analysis and recognition are decoupled. Recognition and reading order execute in parallel within the same model to ensure speed; layout analysis is a separate model that can be replaced as needed. The official rationale: documents across industries vary greatly in language and layout, and no single team can cover all cases. By making layout analysis a replaceable module, users can adjust it themselves when encountering new element categories or region boundaries.

This design has practical significance for real-world deployment—enterprise internal document formats are often highly vertical, and being able to swap out the layout analysis module is far cheaper than swapping out the entire model.

Layout analysis is the first stage of a document parsing pipeline. It is responsible for detecting text blocks, tables, images, headings, headers and footers, and other regions on a page, and providing bounding boxes and categories. Its output determines the processing scope of subsequent recognition modules and how reading order is constructed. Traditional approaches often use object detection models (such as the YOLO series) separately for layout analysis, then hand each region to an OCR engine for recognition. OXR makes layout analysis an independent, replaceable module, meaning users can replace or fine-tune the layout detector for specific industry documents (such as invoices, exam papers, or vertically typeset ancient texts) without modifying the recognition model. This is far cheaper than retraining the entire multimodal model, and it also makes it easier to diagnose whether errors originate in detection or recognition.

RSI (recursive self-improvement) in this context refers to an automated training data construction process: the model first parses a large number of documents, then the system screens out erroneous and uncertain samples based on confidence, consistency checks, or differences from reference answers, and converts them into supervised training data fed back into the next round of training. This way, model iteration no longer relies entirely on manual annotation and can continuously expand difficult samples at lower cost. The limitation of this approach is that if the error detection mechanism itself is biased, errors may become entrenched; meanwhile, the training data distribution will gradually skew toward the model's current weak spots, requiring manual spot checks and independent test sets to prevent overfitting.

Getting Started and License

• Local deployment: Requires Linux and an NVIDIA GPU with BF16 support. 24GB VRAM is enough for low-concurrency testing; long documents or high concurrency are better with 48GB or more. The Docker all-in-one image is the easiest way to start.
• Free API: No registration or API key required, but for testing only; requests will be queued. The team says it will stay online until it can no longer afford the cost.
• Online Demo: Free to try in the browser.
• Repository and weights: GitHub at SoMarkAI/OXR, weights at Hugging Face SoMarkAI/OXR-1.0, with a synchronized release on ModelScope.
• License: Apache 2.0 with additional terms, including thresholds for commercial use; full terms are in the repository's LICENSE.

Some Observations

1.3B parameters is a fairly lightweight tier in the document parsing space. Compared with general multimodal models that often have tens of billions of parameters, OXR's approach is to trade specialized architecture and high-quality training data for efficiency—which is very appealing to teams that need private deployment.

What deserves attention is the reproducibility of the benchmark results. The lead margins on all three leaderboards are modest, especially the first two; rankings might not hold with a different test set. The team themselves admitted in the post that they want user feedback on "where parsing fails," indicating they are aware the model's boundaries on real documents haven't been fully mapped.

For developers building document processing pipelines, OXR is worth adding to the shortlist for a round of hands-on testing, especially for scenarios like handwriting, vertical text, and chemical formulas that previously required specialized solutions.

One-line Summary

OXR, a 1.3B open-source document parsing model, tops three benchmarks simultaneously and ranks first in speed among open-source models.

Paragraph Summary

The SoMarkAI team has open-sourced OXR, a 1.3B-parameter document parsing model that converts PDFs and document images into Markdown or JSON with layout coordinates. It supports 13 element types including tables, formulas, and chemical structure diagrams, and focuses on complex layouts such as A3 exam papers, newspapers, vertical text, and handwriting. Official data shows it ranks first on olmOCR-Bench, OmniDocBench v1.6, and DocParsingBench, though the lead over second place on the first two is less than 0.3 points. In speed tests, it processed 100 pages in 101 seconds, the fastest among 21 open-source models. Architecturally, it decouples layout analysis from recognition in a pluggable design and uses an RSI loop to automatically generate training data. The model is released under Apache 2.0 with additional commercial terms, with a free testing API and online demo.