OXR: Open 1.3B document parser tops three benchmarks, claims its maker
The team behind Chinese startup SoMark has released OXR, an open-weights model with 1.3 billion parameters that turns PDFs and document images into Markdown or JSON. According to the maker, it ranks first on OmniDocBench, olmOCR-Bench and DocParsingBench, and runs faster than PaddleOCR-VL-1.6 and MinerU2.5-Pro.
What it's about
The team behind the document parser SoMark, a startup from China, has open-sourced a model called OXR. The name stands for "Optical Everything Recognition", an extension of OCR (text recognition) beyond plain text. The main model has 1.3 billion parameters (the settings learned during training), which makes it small. It converts PDFs and document images into Markdown or JSON, keeps layout coordinates and recognizes 13 types of elements, including tables, formulas, chemical formulas and code. The article comes from the SoMark site and was republished by QbitAI with permission. All performance figures are the maker's own claims. According to the text, the project gained over 1,000 GitHub stars within a week.
What OXR can do
For tables, correct text recognition isn't enough. If rows, columns or merged cells shift, numbers end up in the wrong entry. OXR preserves the structure and outputs tables as HTML. Formulas come out as LaTeX, chemical equations in mhchem format and structural formulas as SMILES (a text notation for molecules). For multi-column papers, newspapers or exams, the model also determines the reading order so columns don't get mixed up, and it returns coordinates. The output is meant to be usable for agents and RAG systems (systems that feed relevant document excerpts to language models).
Benchmarks and speed
According to the team, OXR achieves the following scores, ranking first on each:
| Benchmark | Score |
|---|---|
| OmniDocBench | 97.18 |
| olmOCR-Bench | 87.84 |
| DocParsingBench | 87.76 |
For speed, 100 pages randomly drawn from OmniDocBench were fully parsed on the same RTX PRO 6000 Blackwell (96 GB):
| Model | Time (approx.) |
|---|---|
| OXR | 101 s |
| PaddleOCR-VL-1.6 | 145 s |
| MinerU2.5-Pro | 255 s |
The architecture splits the work: a lightweight layout model finds content regions, and the main model recognizes the content and determines the reading order. Because the order is produced in the same step, no extra overhead is needed, and the model can use the content to work out the order.
Training with recursive self-improvement
According to the team, OXR is the first to use recursive self-improvement (RSI) for document parsing in post-training. The process works like this: OXR parses unlabeled documents. An external model scores the results and analyzes the causes of errors. An independent clustering model groups the problems. An external model then generates targeted training data for the next round. This way the model gets fixed where it is weak, and no manual annotation is needed.
Swappable layout module
Layout analysis is a separate, swappable module. You can use the built-in model or plug in your own to adjust categories, region boundaries and grouping. For example, you could keep images grouped together for archiving or separate them for image search. OXR's content recognition and reading order remain usable.
What you need to try it
The source gives no minimum requirements. With 1.3B parameters, the model should run in a few GB of VRAM (roughly 3–4 GB at 4-bit, our estimate). The speed test, however, ran on a 96 GB card. The easiest way to test it without installing anything is the online demo (free-oxr.somark.cn) or the free API. Weights: Hugging Face (SoMarkAI/OXR-1.0). Code: GitHub (SoMarkAI/OXR). Whether it works on a Mac, CPU or Colab isn't stated.
Our take
A small, fast model with open weights is attractive for document pipelines, such as papers, reports and archives. But the numbers are the maker's own claims. The source doesn't offer independent tests or details such as license, language coverage and error rates on difficult scans. The text is also a contributed piece provided by SoMark and promotes the commercial SoMark product. If you want to parse in production, compare it against PaddleOCR-VL and MinerU using your own documents.
Sources
- QbitAI 量子位 (CN) qbitai.com
- news.sina.cn news.sina.cn
- r/LocalLLaMA huggingface.co
- r/LocalLLaMA x.com
Try it yourself: OXR-1.0
Explained step by step, no prior knowledge needed – on your own computer or free in your browser.
What can I do with it?
OXR reads documents that come as PDFs or images and turns them into cleanly structured data. The output is Markdown (simply formatted text) or JSON (a machine-readable data format). It also returns coordinates showing where things sit on the page. The model recognizes 13 element types, including text, titles, tables, formulas, chemical equations, structural formulas, code, images and stamps. Tables come out as HTML so rows, columns and merged cells are preserved. Formulas become LaTeX (a notation for math formulas). Chemical equations use the mhchem format, and structural formulas use SMILES (a text notation for molecules). On multi-column pages such as newspapers or papers, OXR also determines the reading order. According to the Model Card, this works for A3 exams, vertical text and handwriting too. At 1.3 billion parameters, OXR is small and, according to the maker, fast. On benchmarks it ranks first by the maker's own account, but those are self-reported figures, and independent tests are still missing. It isn't a chatbot but a specialized tool for documents. You'll get more out of it by feeding it your own files than by chatting with it.
Who is it worth it for?
It's worth trying if you want to turn papers, reports, newspaper pages, exams or archives into usable text. That also goes for tinkerers who want to feed RAG systems (systems that supply a language model with relevant document excerpts) or agents. Without any installation, the online demo or the free API quickly gives you a first impression. It's a poorer fit if you only occasionally want to read a page or you're looking for a chatbot to chat with. And if your documents are confidential, don't use the online demo.
Ideas: What you can do with it
You convert research papers from your collection to Markdown. Because OXR detects the reading order in two-column layouts, the text makes sense. You can then search the result, summarize it or load it into a RAG system.
You take business or research reports and have the tables output as HTML. The HTML keeps merged cells. You can then bring it into a spreadsheet or a script and analyze it.
You photograph pages from lecture notes or exams and get the formulas as LaTeX. You paste those into your own summaries or flashcards. Chemistry reaction equations can also be captured as mhchem text.
You scan old reports, club records or newspaper pages and parse them with OXR. You get text in a sensible order, plus coordinates for images and sections. Test a few pages first to see how well poor scans work.
You parse manuals, policies or product documentation into Markdown or JSON. You give these chunks to a language model as a source. That way it can answer questions about your documents.
Need images handled individually for image search instead of grouped together? Then you plug in your own layout model. OXR still reads the content and determines the order.
What your computer needs
There's the main model OXR-1.0 with 1.3B parameters and a lightweight layout model that finds the content regions. The source doesn't mention quantized variants (shrunken versions). To get started, use the online demo or the free API. The API is compatible with the official SoMark API. That means you can use the SoMark command-line tools (somark-py or somark-js) and just change the base URL. You'll find the weights on Hugging Face (SoMarkAI/OXR-1.0) and ModelScope, and the code on GitHub (SoMarkAI/OXR). For local use, check there for the latest instructions.
- The source gives no minimum requirements. The article's rough estimate is a few GB of VRAM, about 3–4 GB at 4-bit. That isn't a figure from the maker.
- The speed test ran on an RTX PRO 6000 Blackwell with 96 GB. You probably don't need that much memory, but your timings won't be comparable.
- In the test, OXR parsed 100 pages from OmniDocBench in about 101 s. PaddleOCR-VL-1.6 needed about 145 s and MinerU2.5-Pro about 255 s. These are the maker's figures.
- The layout model runs alongside the main model. That costs a bit of extra memory.
- Whether Mac (Apple Silicon), CPU-only use or Google Colab work isn't stated in the source. Check GitHub for details.
- The online demo and the free API need no hardware of your own.
How do I find out what my computer has?
- Windows: Press Ctrl + Shift + Esc → Task Manager → Performance tab → click GPU on the left. At the bottom you'll see Dedicated GPU memory (that's your VRAM). You'll find system memory under Memory.
- Mac: Apple menu at the top left → About This Mac. You'll see your chip (e.g. M2) and memory (e.g. 16 GB). On Apple chips, graphics and processor share this memory.
- Linux: Type
nvidia-smiin the terminal (shows your graphics card and its memory) andfree -hfor system memory.
Guide
This model runs with its developers' own program (SoMarkAI/OXR on GitHub). The commands below come from the Model Card and the developers' instructions.
Windows 10 / 11
Windows 10 / 11: not supported. According to the instructions, OXR runs locally only on Linux with an NVIDIA graphics card. Whether WSL2 works hasn't been tested. Instead, try the online demo at https://free-oxr.somark.ai, where you upload a document with no installation at all.
macOS
macOS: not supported. Macs don't have an NVIDIA graphics card, but OXR needs one (Linux + NVIDIA). Use the online demo at https://free-oxr.somark.ai or the maker's free API.
Linux
Linux: supported. Officially supported: Linux with an NVIDIA graphics card (BF16-capable) and a driver that matches CUDA 13.0. The recommended route is Docker. AMD cards and Mac are not supported.
- Check the prerequisites. You need an NVIDIA graphics card with at least 24 GB of memory and a current NVIDIA driver (matching CUDA 13.0). You also need Python 3.12, Git and Docker with GPU support (NVIDIA Container Toolkit). Allow about 4 GB of free disk space for the model, plus room for the Docker image.
nvidia-smi python3 --version git --version docker --version - Download the program. Get the code from GitHub and change into the folder.
git clone https://github.com/SoMarkAI/OXR.git cd OXR - Create a Python environment. A venv is a separate folder for Python packages so nothing else gets mixed up. You only need it for the model download.
python3 -m venv .venv source .venv/bin/activate - Install the download tool. The huggingface_hub package lets you download models from Hugging Face.
pip install -U huggingface_hub - Download the model. This downloads about 3.1 GB (model plus the small layout model) into the models/OXR-1.0 folder. It may take a while.
hf download SoMarkAI/OXR-1.0 --local-dir ./models/OXR-1.0 - Build the Docker image. Docker packages all services into one container. Stay in the OXR folder. The first build takes longer.
docker build -f docker/Dockerfile.allinone -t oxr-1.0 . - Start the services. The container uses your graphics card and is reachable only from your own machine. Wait until the log says the services are ready. The first start can take up to 900 seconds.
docker run --rm --gpus all --ipc=host \ -p 127.0.0.1:8000:8000 \ -v "$PWD/models/OXR-1.0:/models/oxr-model:ro" \ oxr-1.0 - Parse your first document. Open the demo page in your browser and upload a PDF or an image of a document (for example a scanned letter or invoice). The page http://localhost:8000/docs also shows the interface for programs.
http://localhost:8000/demo - Result. In your browser at http://localhost:8000/demo, your uploaded document is converted to Markdown or JSON with position data.
Try it
Upload a simple single-column PDF page (for example a letter or an invoice) to the online demo and have it output Markdown.Take a page from a quarterly report with a table and have the table output as HTML. Check whether the numbers sit in the right columns.Upload a two-column scientific page and check whether the reading order is correct and the columns aren't mixed up.Photograph a page of formulas from a math or physics textbook and have the formulas output as LaTeX. Then try a chemistry page with a reaction equation (mhchem) and a structural formula (SMILES).Test a newspaper page or an A3 exam with several columns, images and footnotes. For comparison, try a handwritten note and see what comes out. Have the result output as JSON with coordinates.Tips for better results
- Start with the online demo and a single page. That quickly shows you whether the model suits your documents.
- Use clean source material. Sharp scans or PDFs with good contrast help any parser. A shaky photo makes it harder.
- Pick the output format to match your goal: Markdown for reading, JSON with coordinates for further processing. The API's CLI commands support both formats.
- Compare the same page with PaddleOCR-VL or MinerU. That's the only way to tell whether the maker's claims hold for your documents.
- Spot-check tables and formulas against the original. Numbers in the wrong place are easy to miss otherwise.
If something goes wrong
The source doesn't state the license, language coverage or error rates on poor scans. Check the model card on Hugging Face before using the model professionally.
The benchmark scores (OmniDocBench 97.18, olmOCR-Bench 87.84, DocParsingBench 87.76) are the maker's own claims. The article is also a contributed piece from SoMark with promotional content. So test with your own documents and compare against PaddleOCR-VL and MinerU.
The free API isn't meant for production use. The maker guarantees no stability, requests are queued and speed varies. It also only runs as long as the maker can afford it.
Don't upload confidential documents through the demo or the free API. You'd be sending them to someone else's server. For sensitive data, running it locally makes more sense.
According to the Model Card, headers and footers are filtered out by default. If text at the page margin is missing, that's probably why.
If the layout segmentation doesn't suit your purpose, you can swap out the layout module. Content recognition and reading order stay intact. That's only for advanced users, though.
“out of memory,” a crash, or your computer freezes
The model is too big for your VRAM (video memory). Pick a smaller variant from the table above and close other programs, especially games and browsers with lots of tabs.
It runs, but extremely slowly
Your CPU is probably doing the work instead of your graphics card. In Ollama, the PROCESSOR column of ollama ps shows how much runs on the GPU. If it says "100% CPU", update your graphics driver or pick a smaller variant that fits entirely into VRAM (video memory).
“ollama” or “python” is not found
Close the terminal window and open it again so it recognizes the newly installed program. For Python on Windows: reinstall it and check Add python.exe to PATH.
Windows: "Running scripts is disabled on this system"
Run the script with exactly the command above: powershell -ExecutionPolicy Bypass -File try_windows.ps1. This allows execution for this one time only.
Error message when loading the model (version, "trust_remote_code", unknown architecture)
Brand-new models often need the latest software version. With Ollama: update Ollama. With Python: pip install -U transformers in the activated environment. The Model Card usually lists the exact version.
Tokenstrom generates the scripts and notebook automatically. Please take a quick look before running them – they're plain, readable text. Mind the model's license: custom license (see Model Card).
Ask the AI assistant
Questions about this article, installation or background? Our assistant knows this page and runs on our own machine, not in someone else's cloud.
The Assistant is an AI (Gemma 4) and can make mistakes – please check important details against the source. Questions are used only to generate an answer and are deleted after one hour. Please don't enter any personal data.
Comments
What do you think? Already tried it? Write it here, no sign-up needed.
Comments are public. Links aren't allowed, and we delete abusive posts. You can delete your own comment at any time in this browser. Learn more in the Privacy Policy.