We Tested PP-OCRv6 on a Budget Laptop: Tiny vs Small vs Medium

OCR used to mean either a clunky desktop tool or a cloud API that charges you per page and sees your documents. PaddleOCR's PP-OCRv6 changes the math: it's free, open-source (Apache 2.0), runs entirely on your own machine, and — according to Baidu's own benchmarks — outperforms GPT-5.5 and Gemini 3.1 Pro on text recognition with only 34.5M parameters. We wanted to know: does that hold up on a regular laptop with no GPU?

We ran all three tiers — Tiny (1.5M), Small (7.7M), and Medium (34.5M) — on a consumer laptop with four test images of varying difficulty. Here's what we found, including the exact texts, confidence scores, timing, and a CPU crash bug we hit along the way.

What is PP-OCRv6?

PP-OCRv6 is the latest generation of Baidu's open-source OCR model family, released June 2026 as part of PaddleOCR 3.7.0. It comes in three tiers designed for different deployment scenarios:

Key improvements over PP-OCRv5: +4.6% detection accuracy and +5.1% recognition accuracy (Medium tier), 50 languages in a single model (Chinese, English, Japanese, and 46 Latin-script languages), and 5.2× CPU speedup with OpenVINO. The model supports scene text, documents, screenshots, and even digital displays and tire prints.

For context: PaddleOCR has 70k+ GitHub stars and is used by major projects including Dify, RAGFlow, and Cherry Studio. The full source is at github.com/PaddlePaddle/PaddleOCR.

Test setup

We kept the environment deliberately ordinary — the kind of laptop someone might use for daily work:

We generated four test images using PIL (Python Imaging Library), each with different characteristics to stress different OCR capabilities:

• test_small.png — Clean Chinese + English mixed text on white background, 4 lines, standard fonts.
• test_en.png — Dense English paragraph with special characters, 7 lines, multiple font sizes.
• test_noisy.png — Low-contrast text (#666 on #f0f0f0) with 2,000 random noise pixels, 3 lines.
• test_hand.png — Simulated handwriting style with slight horizontal jitter, 3 lines.

Each image was processed by each model tier twice: once as a cold start (first inference, includes graph construction) and once as a warm repeat (steady-state timing). Model load time was measured separately.

Speed results

Here's how long each tier took to process the dense 7-line English test image:

*Medium tier load time includes downloading ~139MB of model files on first run. On subsequent runs with cached models, load time drops to ~15s.

For the smaller 4-line Chinese+English image, all tiers were faster:

The Tiny tier processes a simple image in under 2 seconds — fast enough for interactive use. Small is 3-5 seconds, which is fine for batch processing but noticeable in a real-time UI. Medium at 5-12 seconds per image is too slow for interactive use on a CPU; it's designed for GPU servers.

Accuracy results

We measured accuracy as the average recognition confidence score across all detected text blocks. Note: confidence scores reflect the model's own certainty, not a character-level error rate. To check real accuracy, we also compared the recognized text against ground truth manually.

The scores are high across all tiers — PP-OCRv6 is genuinely good at reading text. But the interesting story is in where each tier succeeds and fails. Confidence scores alone don't tell the full picture, so let's look at actual errors.

Error samples: what each tier got wrong

This is where first-hand testing earns its keep. All tiers made some errors, but the patterns differ:

Three patterns stand out:

1. The "T" drop — All three tiers dropped the "T" from "The quick brown fox," reading it as "he quick brown fox." This is likely because our test image rendered "T" with a thin stroke that the detection model didn't pick up as a separate character. This is a rendering artifact, not a model limitation — real-world documents with standard fonts won't trigger this.
2. "Chalienging" instead of "Challenging" — All tiers misread "ll" as "li" in the noisy image. This is a genuine limitation in low-contrast scenarios where character strokes blend together.
3. Small misread "低" as "氏" — In the low-contrast noisy image, the Small tier confused the Chinese character "低" (low) with "氏" (clan). The Medium tier got it right. This is the clearest accuracy gap between tiers we observed.

Overall, Medium corrected two errors that Small and Tiny both made (the "2.0I" → "2.0 |" pipe character confusion and the "低" → "氏" character confusion). Tiny introduced one additional error (spacing loss in Chinese text). For clean, high-contrast images, the difference between tiers is negligible. For difficult images, Medium earns its size.

The oneDNN bug (and the fix)

When we first ran the benchmark, PaddlePaddle 3.3.1 crashed on our Intel i5 with the following error:

ConvertPirAttribute2RuntimeAttribute not support

This is a known bug in PaddlePaddle 3.3.1's oneDNN (formerly MKLDNN) integration on certain Intel CPUs. The oneDNN backend is supposed to accelerate CPU inference using Intel's optimized math library, but the PIR (Paddle Intermediate Representation) attribute conversion fails on some CPU architectures.

The fix is simple — disable oneDNN when initializing the OCR object:

ocr = PaddleOCR(
    text_detection_model_name="PP-OCRv6_small_det",
    text_recognition_model_name="PP-OCRv6_small_rec",
    enable_mkldnn=False  # <-- the fix
)

This falls back to PaddlePaddle's native CPU inference engine, which works correctly on all processors. On our 11th-gen i5, the performance difference was negligible — the oneDNN acceleration benefit is more meaningful on server-grade Xeon processors. If you hit this error, add enable_mkldnn=False and move on.

Which tier should you pick?

For our own use — a desktop assistant that occasionally needs to read screenshots, receipts, and document images — we're going with Small. It's fast enough for interactive use (under 5 seconds), accurate enough that we don't need to double-check every result, and the 7.7MB model size means it loads in under 2 seconds once cached.

If you need OCR for a web app and don't want to deal with Python or PaddlePaddle, PaddleOCR also offers a cloud API and a browser SDK (PaddleOCR.js) that can run PP-OCRv5 directly in the browser. The browser SDK hasn't been updated to v6 yet as of September 2026, but the Tiny tier's 1.5MB size makes it a natural fit for client-side deployment when it arrives.

Frequently asked questions

Next: check out our other free tools that replace paid apps, or see our Photopea vs Photoshop test for another first-hand tool comparison.