NVIDIA-Nemotron-Parse-2.0 vs PaddleOCR-VL: The Quiet Challenger vs the Proven SOTA

Document parsing is in the middle of an open-weight SOTA race, and the two contestants are not playing on the same field. PaddleOCR-VL, the 0.9B parser from Baidu's PaddlePaddle team, sits on top of OmniDocBench v1.6 with a 96.33 composite score, three releases in ten months, and the largest ecosystem in OCR gathered around it. NVIDIA-Nemotron-Parse-2.0, the other contestant, appeared on Hugging Face on August 3, 2026, with no announcement, no hosted endpoint, and a model card whose numbers no one outside NVIDIA has verified yet. That pair of facts turns this into the incumbency question: which open-weight parser do you bet the parsing stage of your pipeline on — the one with a public leaderboard record, or the one that shipped quietly claiming it fixed the languages everyone else struggles with?

Two ways to build a page parser

Both models come in at around 0.9B parameters, both are open-weight, and both are built to be self-hosted. That is where the similarity ends, because the two sit on opposite architectural philosophies.

PaddleOCR-VL is a two-stage pipeline. A layout model, PP-DocLayoutV3, first detects every element on a page, classifies it, and predicts the reading order. Only then does the PaddleOCR-VL vision-language model — a NaViT-style dynamic-resolution vision encoder paired with Baidu's lightweight ERNIE-4.5-0.3B language model — recognize each region: the text, the tables, the formulas, the charts. Baidu's argument for the split is that separating layout from recognition avoids the hallucination and element-misalignment failure modes that end-to-end models show on complex, multi-column pages.

NVIDIA-Nemotron-Parse-2.0 is the opposite bet: a single end-to-end model. A ViT-H vision encoder built on NVIDIA's C-RADIOv2 backbone feeds a ten-layer mBART-style decoder, and the whole thing maps a page image directly to reading-order text, bounding boxes, semantic classes, and markdown in one pass. There is no separate layout stage to install, tune, or version.

The spec sheet reads accordingly:

• Architecture — PaddleOCR-VL: layout detection (PP-DocLayoutV3) plus a 0.9B recognition VLM (NaViT encoder + ERNIE-4.5-0.3B). NVIDIA-Nemotron-Parse-2.0: one 0.9B vision-encoder-decoder (ViT-H C-RADIOv2 + mBART-style decoder).

• Output contract — both return reading-order text, a bounding box and semantic class per region, and markdown. PaddleOCR-VL adds task-specific prompts for text, table, formula, chart, spotting, and seal recognition; Parse 2.0 emits tables as LaTeX, HTML, markdown, JSON, or CSV and in 2.0 gained a dedicated chart semantic class.

• Context — PaddleOCR-VL 1.6 supports up to 131,072 tokens of context; Parse 2.0's card documents inputs up to 2048×1664 and a 9,000-token output ceiling.

• License — PaddleOCR-VL is Apache 2.0; Parse 2.0 is under the NVIDIA Open Model License with the tokenizer under CC-BY-4.0. Both permit commercial use.

The benchmark problem: 96.33% vs a number nobody can check

This is the part where the matchup stops being a comparison and becomes a sourcing question.

PaddleOCR-VL's current release, PaddleOCR-VL 1.6, dated May 28, 2026, reports 96.33% on OmniDocBench v1.6 — a composite of text, formula, and table recognition plus reading-order prediction — and 93.19% on Real5-OmniDocBench, a robustness variant for warped, skewed, and screen-photographed pages, where Baidu says it leads Gemini-3-Pro by nearly four points. Those are Baidu's own figures, but they are reported on the field's shared public benchmark, which is why they can be ranked against MinerU 2.5-Pro, GLM-OCR, and the rest of the leaderboard.

NVIDIA-Nemotron-Parse-2.0 reports a different set of numbers on a different suite. ParseBench overall 0.6391, up from 0.5782 on v1.2; MOSCAR multilingual F1 0.9102, up from 0.4410; IndicVisionBench ANLS 0.7203, up from 0.0612; and OmniDocBench Notes handwriting edit distance down to 0.3395 from 0.9739. Every one of those is NVIDIA's own, printed on the model card, and none has been independently reproduced. ParseBench is NVIDIA's suite; MOSCAR and IndicVisionBench are specialist sets. There is no published run of Parse 2.0 on the OmniDocBench composite that PaddleOCR-VL tops, and no run of PaddleOCR-VL on ParseBench.

So the honest answer to "who scores higher" is that nobody knows yet, and anyone who claims otherwise is comparing different yardsticks. The single point of overlap is handwriting on OmniDocBench Notes, where Parse 2.0's card claims a large edit-distance improvement over its own predecessor — but that is a task-level number, not the composite score PaddleOCR-VL reports. The asymmetry that actually matters is structural: PaddleOCR-VL's 96.33 is a leaderboard position anyone can look up, while Parse 2.0's claims are a five-day-old repo with zero third-party checks.

Languages: coverage vs claimed deltas

Both models lead their pitch with languages, and both have a story — but the stories have different shapes.

PaddleOCR-VL's multilingual story is coverage that is already shipped: 109 languages, with particular depth where multilingual OCR is hardest — Chinese ancient documents, rare Chinese characters, seal and stamp recognition, vertical text, and irregular box localization for tilted or folded pages. It is the parser the Chinese-document pipeline world adopted for exactly that reason.

NVIDIA-Nemotron-Parse-2.0's story is a claimed delta. The vocabulary grows from 52,329 to 72,256 tokens, and the card attributes the growth to multilingual OCR, with the largest gains claimed on CJK and Indic scripts. The MOSCAR jump from 0.44 to 0.91 and IndicVisionBench from 0.06 to 0.72 are claims that the scripts that used to fail now parse acceptably — across Bengali, Hindi, Telugu, Tamil, and six more Indic languages, per the card.

Which one matters depends on what you parse. If your corpus is Chinese-language or broadly CJK, PaddleOCR-VL is the proven, leaderboard-backed choice, and the only real question is whether you need its full pipeline or just the model. If your corpus leans Indic — Bengali, Hindi, Gujarati, Kannada, and their neighbors — Parse 2.0's claimed delta is the single most interesting number on its card, and it is exactly the kind of claim that either replicates on your data or collapses. No one has run Parse 2.0 on a public Indic benchmark yet.

The maturity gap is the real price

Neither model costs anything per page — both are free weights you serve yourself — so the price that matters is the operational one, and there the gap is wide.

PaddleOCR-VL is a settled platform. Native vLLM support is in the framework itself (vllm/model_executor/models/paddleocr_vl.py, vLLM 0.11.1 or later); Baidu ships an official high-performance deployment with a FastAPI gateway, Triton for the layout stage, and vLLM for the VLM; there are community GGUF quantizations; PaddleOCR-VL 1.5 added AMD ROCm day-one support; and the model is wired into the tools most people already run — RAGFlow, MinerU, Umi-OCR, and OmniParser all integrate it. Moving from 1.5 to 1.6 is zero-cost because the architecture is unchanged.

NVIDIA-Nemotron-Parse-2.0 is five days old and it shows. Serving it means a vLLM build with Nemotron Parse remote-code support, the Triton attention backend on A100/A10-class hardware, and four extra dependencies (albumentations, timm, open_clip_torch, einops). The model keeps its output head tied to the decoder embeddings, which some vLLM builds mishandle unless you add NVIDIA's included runtime patch. And the shipped tokenizer.json has padding baked in to 9,000 tokens — a Dynamo maintainer hit a live case in early August where a short prompt ballooned into tens of thousands of token IDs. None of this is fatal; all of it is engineering time that a settled platform never asks for. There is also no hosted endpoint and no NIM packaging listed for 2.0, so self-hosting is the only option.

Speed: both fast, one claimed

For a page parser, throughput is the number that turns into money. PaddleOCR-VL's headline figure is roughly 1,881 tokens per second on a single A100, claimed at the v1.0 launch and still vendor-reported — fast enough that the 0.9B model is routinely used for high-volume OCR. NVIDIA-Nemotron-Parse-2.0 is a 0.9B end-to-end model, so it is fast by construction, and the ecosystem is already pushing further: a vLLM pull request in review as of August 5 enables speculative decoding using the auxiliary prediction head NVIDIA ships alongside the weights, reporting median output-throughput gains of 45.65% at concurrency 1, 40.85% at concurrency 8, and 39.60% at concurrency 32 on an H100 over ParseBench's 1,005 pages. That PR is unmerged and unreproduced — treat the percentages as directionally interesting, not as a benchmark you can cite.

Who should pick which

• Pick PaddleOCR-VL if you need a parsing stage that works this quarter: Chinese or multilingual-CJK documents, table and formula extraction at the SOTA level, vLLM or Docker deployment, and a leaderboard record you can point to in a meeting. It is the low-risk production choice, and it is the answer for anyone whose corpus is majority-CJK.

• Pick NVIDIA-Nemotron-Parse-2.0 if you already self-host the Nemotron Parse family — 2.0 is a drop-in upgrade with the same API shape — if your corpus is heavy on Indic scripts or handwriting and you want to test whether the card's deltas replicate, or if a dedicated chart semantic class is worth real engineering time. Budget for the early-adopter friction, and do not bet a production path on it before your own evaluation.

• Take the middle path if your pipeline is really "parser, then LLM" — which most are. The parser is one stage; the model that summarizes the markdown, extracts fields, or answers retrieval questions is a separate stage, and that second stage is where a routing platform earns its keep. Neither parser in this comparison is on OrcaRouter — both are self-hosted open weights — but the layer around them is exactly what OrcaRouter is for: 200+ models behind one API at the provider's list price, 0% markup so a vendor price cut is live the same day it is announced, and automatic failover if one provider degrades. The practical version of that advice: if you are going to bet a pipeline on an unproven parser, keep everything around it swappable, so that failing over from Parse 2.0 to PaddleOCR-VL or to a different LLM is a routing change rather than a rewrite.

Bottom line

The choice here is not really between two models — it is between a public record and a private claim. PaddleOCR-VL 1.6 is the proven open-weight SOTA: 96.33 on OmniDocBench v1.6, 109 languages, a settled serving stack, and the ecosystem already built around it. NVIDIA-Nemotron-Parse-2.0 is the quiet challenger: five days old, unannounced, self-hosted-only, with a model card claiming very large multilingual and handwriting gains that nobody has verified. The 96.33 and the 0.6391 cannot be compared directly, and pretending otherwise is how teams end up citing numbers that mean different things. If you ship today, ship PaddleOCR-VL. If the multilingual claim is the thing your corpus tests, the quiet challenger is a cheap weekend evaluation on your own documents — the deltas are the kind that either replicate or collapse, and a quiet release is the cheapest way to find out which.

FAQ

Can I compare PaddleOCR-VL and NVIDIA-Nemotron-Parse-2.0 on a single benchmark today?

Not meaningfully. PaddleOCR-VL's 96.33 is an OmniDocBench v1.6 composite — the field's shared public benchmark — while Parse 2.0's numbers are ParseBench (NVIDIA's own suite), MOSCAR, IndicVisionBench, and an OmniDocBench handwriting subset, all vendor-reported. No independent run of Parse 2.0 exists on the OmniDocBench composite, and no run of PaddleOCR-VL exists on ParseBench. The only overlap is handwriting on OmniDocBench Notes, and even there the two models report different kinds of scores. Until a third party runs Parse 2.0 on the common benchmark, the comparison is apples-to-oranges.

Which model handles Chinese and other CJK documents better?

As of today, PaddleOCR-VL, and it is not close on evidence. Baidu's model is CJK-native, holds the public SOTA on the benchmark the field ranks by, and has documented strength in Chinese ancient documents, rare characters, and seal recognition. NVIDIA-Nemotron-Parse-2.0's card claims large CJK and Indic gains over v1.2, but those numbers are vendor-reported and have not been independently tested. The claim is worth testing if you parse those scripts; it is not yet a result you can rely on.

Are both models free to use, and how do I run them?

Both are free weights with commercial use permitted — PaddleOCR-VL under Apache 2.0, Parse 2.0 under the NVIDIA Open Model License — but neither is a hosted API on a routing platform, and Parse 2.0 has no hosted option at all. PaddleOCR-VL runs natively in vLLM, in Baidu's official Docker deployment, and via the PaddleOCR website and Baidu's cloud API. Parse 2.0 must be self-hosted with a vLLM build that supports Nemotron Parse remote code, plus the tied-output-head patch and a tokenizer fix. The parsing stage is on you either way; what a routing layer adds is the LLM stage after it, where you want the freedom to swap models without re-engineering the pipeline.