PP-OCRv6 Is Here: Day-0 OpenVINO™ Support Brings Local OCR to AI PCs Across CPU, GPU, and NPU
If you are working on document intelligence, screen text extraction, industrial character recognition, or building a local AI application that can “read” text from images on a PC, OCR is probably an essential part of your workflow.
OCR may look like a mature task, but once developers try to turn it into a real product, several practical challenges quickly appear.
Cloud-based OCR APIs are convenient, but data privacy, network latency, and service cost can become limiting factors.
Large multimodal models are powerful, but they are not always the most cost-effective choice for real-time cameras, edge deployments, or high-throughput batch scanning.
Traditional OCR pipelines are lightweight, but running them efficiently and reliably across CPU, GPU, and NPU still requires careful engineering.
This is why the PaddleOCR family has remained popular among developers. It is not a general-purpose large model that tries to do everything. Instead, it is a practical OCR system with a mature engineering pipeline, lightweight models, and a deployment-friendly design. As the PaddleOCR 3.x ecosystem continues to evolve, the newly released PP-OCRv6 model is now supported by OpenVINO from day one and can run on the CPU, GPU, and NPU of Intel AI PCs.
In this blog, we use a real-time camera OCR demo to highlight the value of PP-OCRv6 tiny and show how OpenVINO enables hybrid deployment of the complete OCR pipeline on an AI PC.
Why PP-OCRv6 Tiny Matters
The core value of PP-OCRv6 tiny is not about having more parameters. Instead, it continues the engineering philosophy of OCR-specialized models: lightweight design, low latency, controllable outputs, and easy integration into real business workflows.
Compared with sending every visual-text task to a general-purpose multimodal large model, OCR-specialized models are often more economical and easier to productize in scenarios such as text localization, continuous-frame processing, batch scanning, and local deployment.
A typical OCR application is not a single-model task. It is a complete pipeline:
Image input
-> Text detection
-> Text box cropping and sorting
-> Text recognition
-> CTC decoding
-> Visualization or business post-processing
PP-OCRv6 tiny continues the lightweight design of the PP-OCR series by splitting detection and recognition into two compact models.
PP-OCRv6_tiny_det_onnx
PP-OCRv6_tiny_rec_onnx This separation is very developer-friendly. The detection model is responsible for locating text regions in the full image, while the recognition model only needs to process cropped text images. At the same time, developers can flexibly adjust the overall OCR pipeline based on input types, text density, and business requirements.
For real-time camera OCR, screen text extraction, batch document scanning, and industrial character recognition, PP-OCRv6 tiny provides a lightweight, controllable, and deployment-friendly OCR solution.
Day-0 Support: Not Just Running, But Running Smoothly
Many model support announcements stop at the point where the model can be successfully compiled. But for real OCR applications, model inference is only one part of the end-to-end experience.
Camera capture, image resizing, text box post-processing, cropping multiple text regions, CTC decoding, result rendering, and window display all affect whether the application feels smooth, stable, and usable.
This is where OpenVINO brings value when deploying PP-OCRv6 tiny on AI PCs.
An AI PC provides different types of computing resources, including CPU, GPU, and NPU. Meanwhile, an OCR pipeline itself contains different types of workloads. Developers do not have to place all models and processing logic on the same device. Instead, they can use heterogeneous deployment strategies based on the characteristics of each task.
For example, in a real-time OCR scenario, the GPU can be used for full-image text detection, taking advantage of its parallel image-processing capabilities. The NPU can be used to run the text recognition model, reducing pressure on GPU resources. The CPU can continue to handle preprocessing, post-processing, sorting, decoding, and UI logic.
This division of workload allows different compute units to focus on the tasks they are best suited for, achieving a better balance among performance, power efficiency, stability, and user experience.
For developers, the value of OpenVINO is not only that PP-OCRv6 tiny can run separately on CPU, GPU, and NPU. More importantly, OpenVINO provides a unified runtime that allows the OCR pipeline to be flexibly deployed across the hybrid architecture of an AI PC.
Whether you are building real-time camera OCR, batch document processing, screen text extraction, or industrial character recognition, you can use the same codebase and adjust the deployment strategy based on the target device and application workload. This makes it easier to move from demo to real-world applications.
Step-by-Step Guide: Deploying PP-OCRv6 Tiny with OpenVINO
In the following example, we use PP-OCRv6 tiny ONNX models to demonstrate how to read models, assign devices, compile models, and run the OCR pipeline on an AI PC with OpenVINO.
Get OpenVINO™ toolkit’s stories in your inbox
Join Medium for free to get updates from this writer.
The overall process can be summarized in three steps: read the detection and recognition models, assign devices according to a heterogeneous deployment strategy, and compile the models before connecting them to the real-time OCR pipeline.
Step 1: Load the PP-OCRv6 Tiny Models
PP-OCRv6 tiny consists of a text detection model and a text recognition model. In this example, we directly use the ONNX-format models, so there is no need to install the PaddlePaddle Runtime. OpenVINO Runtime can read the model files directly.
import openvino as ov
from pathlib import Path
core = ov.Core()
# PP-OCRv6 tiny ONNX models
det_model_file_path = Path("model/PP-OCRv6_tiny_det_onnx/inference.onnx")
rec_model_file_path = Path("model/PP-OCRv6_tiny_rec_0515_onnx/inference.onnx")
det_model = core.read_model(det_model_file_path)
rec_model = core.read_model(rec_model_file_path) Step 2: Assign Devices for the OCR Pipeline
The device selection logic keeps a simple hybrid strategy. When the user selects GPU or AUTO, the detection model is prioritized on the GPU, while the recognition model is prioritized on the NPU. If no NPU is available, recognition falls back to the CPU.
DEVICE_STRATEGY = "HYBRID"
def resolve_ocr_devices(selected_device, available_devices):
if selected_device == "AUTO":
det_device = "GPU" if "GPU" in available_devices else "CPU"
else:
det_device = selected_device
if DEVICE_STRATEGY == "HYBRID" and det_device == "GPU":
rec_device = "NPU" if "NPU" in available_devices else "CPU"
else:
rec_device = det_device
return det_device, rec_device
available_devices = core.available_devices
det_device, rec_device = resolve_ocr_devices("AUTO", available_devices) Step 3: Compile the Models
During compilation, the appropriate shapes are set according to the selected devices.
# Detection: fixed shape for GPU/NPU
if det_device in ["GPU", "NPU"]:
det_model.reshape({det_model.input(0): ov.PartialShape([1, 3, 640, 640])})
det_compiled_model = core.compile_model(det_model, det_device)
# Recognition: NPU/GPU use fixed shape; CPU keeps dynamic width
if rec_device == "NPU":
rec_model.reshape({rec_model.input(0): ov.PartialShape([1, 3, 48, 320])})
elif rec_device == "GPU":
rec_model.reshape({rec_model.input(0): ov.PartialShape([6, 3, 48, 320])})
else:
for input_layer in rec_model.inputs:
input_shape = input_layer.partial_shape
input_shape[3] = -1
rec_model.reshape({input_layer: input_shape})
rec_compiled_model = core.compile_model(rec_model, rec_device) Step 4: Connect to the Real-Time OCR Pipeline
Finally, the compiled models can be connected to a camera or video file to run real-time OCR.
# webcam
source = 0
run_paddle_ocr(source, flip=False, use_popup=True, popup_side_by_side=True)
# video file
# source = Path("test.mp4")
# run_paddle_ocr(source, flip=False, use_popup=True, popup_side_by_side=True) Below is the result of running real-time camera video capture and OCR inference on an Intel® Core™ Ultra X7 358H laptop.
Summary
Day-0 support for PP-OCRv6 tiny with OpenVINO shows more than just a new model running successfully. It demonstrates a practical deployment pattern for edge AI applications on AI PCs.
In this pipeline, the CPU handles preprocessing, post-processing, and UI logic. The GPU processes full-image text detection. The NPU runs the text recognition model. This heterogeneous deployment approach helps developers build OCR applications that are lightweight, responsive, and ready for real-world use on Intel AI PCs.
Additional Resources
- OpenVINO 2026.2 Documentation
- OpenVINO™ Model Hub
- OpenVINO Hugging Face collection
- AI Reference Kits from Intel
- OpenVINO™ GenAI
Notices and Disclaimers
*Other names and brands may be claimed as the property of others.
Performance varies by use, configuration, and other factors. Learn more on the Performance Index site.
Performance results are based on testing as of dates shown in configurations and may not reflect all publicly available updates.
No product or component can be absolutely secure.
Your costs and results may vary.
Intel technologies may require enabled hardware, software, or service activation.
© Intel Corporation. Intel, the Intel logo, and other Intel marks are trademarks of Intel Corporation or its subsidiaries.
