PaddleSharp (Sdcb.PaddleOCR) sits three abstraction layers away from the OCR engine your code actually runs: Baidu trains the neural network models, RapidOCR re-packages them for lightweight inference, and PaddleSharp wraps that again for .NET consumption. Every layer adds a maintenance dependency, and the chain shows its limits the moment you need a language outside CJK, a PDF as input, or a production deployment without CUDA. This comparison examines where that architecture pays off and where it extracts a cost .NET teams rarely anticipate upfront.

Understanding PaddleSharp OCR

PaddleSharp is a .NET wrapper around Baidu's PaddleOCR deep learning framework, published on NuGet as Sdcb.PaddleOCR. Rather than using traditional OCR algorithms, PaddleOCR applies a three-stage neural network pipeline: a detection model locates text regions in the image, a classifier model determines text orientation, and a recognition model converts each region to text. Each stage is a separate model file you download and configure independently.

The wrapper was built to bring PaddlePaddle inference to .NET without requiring Python. That goal is technically achieved, but the cost is a dependency stack that includes the OpenCvSharp image processing library (itself requiring platform-specific runtime packages), the PaddleInference native runtime, and the model files themselves. On Windows, the setup involves at minimum four NuGet packages before a single character can be recognized.

Key architectural characteristics of PaddleSharp:

• Wrapper depth: Three layers - PaddlePaddle (Baidu) → PaddleOCR models → Sdcb.PaddleSharp .NET bindings
• Model management: Detection, classification, and recognition models are separate downloads (~3MB, ~2MB, and ~10MB respectively for the Chinese V3 set); you manage paths and versions manually
• OpenCV dependency: OpenCvSharp4 is required for image loading; switching platforms requires swapping the OpenCvSharp4.runtime.* package
• Language focus: Primary strength is Chinese and English; other language support is limited to what PaddleOCR model packs are available and maintained
• GPU acceleration: Native CUDA support via the Sdcb.PaddleInference.runtime.win64.cuda package, which requires a compatible CUDA toolkit and cuDNN installation on the host
• CPU performance penalty: Without GPU, inference is slower than CPU-optimized alternatives - 500-1500ms per image versus 100-400ms for optimized non-deep-learning engines
• Community footprint: Small English-language community; most documentation, Stack Overflow answers, and GitHub issues are in Chinese

The Three-Stage Inference Setup

Setting up PaddleSharp for a simple text extraction task requires wiring together all three model stages:

// Simplified — see Sdcb.PaddleOCR documentation for full API
using Sdcb.PaddleOCR;
using Sdcb.PaddleOCR.Models;
using OpenCvSharp;

public class PaddleOcrService
{
    private readonly PaddleOcrAll _ocr;

    public PaddleOcrService()
    {
        // Three separate models, each downloaded independently
        var detModel = LocalFullModels.ChineseV3.DetectionModel;
        var clsModel = LocalFullModels.ChineseV3.ClassifierModel;
        var recModel = LocalFullModels.ChineseV3.RecognitionModel;

        // GPU config: set GpuDeviceId = 0 and install CUDA runtime packages
        _ocr = new PaddleOcrAll(detModel, clsModel, recModel);
    }

    public string ExtractText(string imagePath)
    {
        // OpenCV required for image loading — not System.Drawing
        using var image = Cv2.ImRead(imagePath);
        var result = _ocr.Run(image);

        // Manual sort by position; no automatic reading-order guarantee
        return string.Join("\n", result.Regions
            .OrderBy(r => r.Rect.Center.Y)
            .ThenBy(r => r.Rect.Center.X)
            .Select(r => r.Text));
    }
}

// Simplified — see Sdcb.PaddleOCR documentation for full API
using Sdcb.PaddleOCR;
using Sdcb.PaddleOCR.Models;
using OpenCvSharp;

public class PaddleOcrService
{
    private readonly PaddleOcrAll _ocr;

    public PaddleOcrService()
    {
        // Three separate models, each downloaded independently
        var detModel = LocalFullModels.ChineseV3.DetectionModel;
        var clsModel = LocalFullModels.ChineseV3.ClassifierModel;
        var recModel = LocalFullModels.ChineseV3.RecognitionModel;

        // GPU config: set GpuDeviceId = 0 and install CUDA runtime packages
        _ocr = new PaddleOcrAll(detModel, clsModel, recModel);
    }

    public string ExtractText(string imagePath)
    {
        // OpenCV required for image loading — not System.Drawing
        using var image = Cv2.ImRead(imagePath);
        var result = _ocr.Run(image);

        // Manual sort by position; no automatic reading-order guarantee
        return string.Join("\n", result.Regions
            .OrderBy(r => r.Rect.Center.Y)
            .ThenBy(r => r.Rect.Center.X)
            .Select(r => r.Text));
    }
}

Imports Sdcb.PaddleOCR
Imports Sdcb.PaddleOCR.Models
Imports OpenCvSharp

Public Class PaddleOcrService
    Private ReadOnly _ocr As PaddleOcrAll

    Public Sub New()
        ' Three separate models, each downloaded independently
        Dim detModel = LocalFullModels.ChineseV3.DetectionModel
        Dim clsModel = LocalFullModels.ChineseV3.ClassifierModel
        Dim recModel = LocalFullModels.ChineseV3.RecognitionModel

        ' GPU config: set GpuDeviceId = 0 and install CUDA runtime packages
        _ocr = New PaddleOcrAll(detModel, clsModel, recModel)
    End Sub

    Public Function ExtractText(imagePath As String) As String
        ' OpenCV required for image loading — not System.Drawing
        Using image = Cv2.ImRead(imagePath)
            Dim result = _ocr.Run(image)

            ' Manual sort by position; no automatic reading-order guarantee
            Return String.Join(vbLf, result.Regions _
                .OrderBy(Function(r) r.Rect.Center.Y) _
                .ThenBy(Function(r) r.Rect.Center.X) _
                .Select(Function(r) r.Text))
        End Using
    End Function
End Class

Imports Sdcb.PaddleOCR
Imports Sdcb.PaddleOCR.Models
Imports OpenCvSharp

Public Class PaddleOcrService
    Private ReadOnly _ocr As PaddleOcrAll

    Public Sub New()
        ' Three separate models, each downloaded independently
        Dim detModel = LocalFullModels.ChineseV3.DetectionModel
        Dim clsModel = LocalFullModels.ChineseV3.ClassifierModel
        Dim recModel = LocalFullModels.ChineseV3.RecognitionModel

        ' GPU config: set GpuDeviceId = 0 and install CUDA runtime packages
        _ocr = New PaddleOcrAll(detModel, clsModel, recModel)
    End Sub

    Public Function ExtractText(imagePath As String) As String
        ' OpenCV required for image loading — not System.Drawing
        Using image = Cv2.ImRead(imagePath)
            Dim result = _ocr.Run(image)

            ' Manual sort by position; no automatic reading-order guarantee
            Return String.Join(vbLf, result.Regions _
                .OrderBy(Function(r) r.Rect.Center.Y) _
                .ThenBy(Function(r) r.Rect.Center.X) _
                .Select(Function(r) r.Text))
        End Using
    End Function
End Class

The constructor alone does real work: it loads model binaries from disk and initializes the inference engine. That initialization cost is paid once per PaddleOcrAll instance, which makes the object expensive to create and requires careful lifecycle management in service-oriented .NET applications.

Understanding IronOCR

IronOCR is a commercial OCR library for .NET built on an optimized Tesseract 5 engine with an automatic preprocessing pipeline layered on top. It installs as a single NuGet package with no external model files, no native binary configuration, and no secondary image-processing library dependencies. The design goal is to eliminate the gap between "install" and "accurate text output" - a gap that defines most other .NET OCR options.

Key characteristics of IronOCR:

• Single package deployment: dotnet add package IronOcr - no model downloads, no tessdata folders, no OpenCV
• Automatic preprocessing: Deskew, denoise, contrast enhancement, binarization, and resolution normalization happen automatically on image input; explicit preprocessing filters are available when needed
• Native PDF support: Both scanned and text-layer PDFs are accepted directly; password-protected PDFs require one parameter
• 125+ languages: Delivered as individual NuGet language packs (e.g., IronOcr.Languages.ChineseSimplified), managed the same way as any package dependency
• Structured output: Results expose pages, paragraphs, lines, words, and individual character bounding boxes with confidence scores
• Thread-safe: Multiple IronTesseract instances run concurrently without shared state; parallelizing a batch workload is a Parallel.ForEach call
• Pricing: $999 perpetual (Lite, 1 developer), $1,499 (Plus, 3 developers), $2,399 (Professional, 10 developers), $4,799 (Unlimited)

Feature Comparison

Detailed Feature Comparison

Abstraction Depth and Maintenance Risk

PaddleSharp is the only .NET OCR option in this category that runs three separate upstream projects as prerequisites. That depth is the central risk for production teams.

PaddleSharp Approach

The dependency chain looks like this in practice:

1. Baidu PaddlePaddle - the underlying deep learning framework. Model formats and inference APIs are defined here.
2. PaddleOCR - Baidu's model training project that produces the detection, classification, and recognition model weights.
3. Sdcb.PaddleSharp - the .NET binding layer that calls PaddleInference native libraries and wraps the model loading API.

Each layer has its own release cadence, breaking change history, and community. When Baidu updates PaddlePaddle inference APIs, the binding layer must catch up. When a model format changes between PaddleOCR versions, the model download paths and loading code in PaddleSharp must be updated. For a .NET team, these are invisible until a deployment fails.

A simplified illustration of the initialization cost:

// Simplified — see Sdcb.PaddleOCR documentation for full API
// This is not one line of setup; it represents several coordinated decisions:
// - Which model version to use (ChineseV3, V4, etc.)
// - Whether models are local files or downloaded on first use
// - Which inference backend (CPU, MKL, GPU)
// - Which OpenCvSharp runtime package matches the deployment OS

var detModel = LocalFullModels.ChineseV3.DetectionModel;  // Version-specific
var clsModel = LocalFullModels.ChineseV3.ClassifierModel; // Version-specific
var recModel = LocalFullModels.ChineseV3.RecognitionModel; // Version-specific

var ocr = new PaddleOcrAll(detModel, clsModel, recModel);
// If a newer model format is released, these names and classes may change

// Simplified — see Sdcb.PaddleOCR documentation for full API
// This is not one line of setup; it represents several coordinated decisions:
// - Which model version to use (ChineseV3, V4, etc.)
// - Whether models are local files or downloaded on first use
// - Which inference backend (CPU, MKL, GPU)
// - Which OpenCvSharp runtime package matches the deployment OS

var detModel = LocalFullModels.ChineseV3.DetectionModel;  // Version-specific
var clsModel = LocalFullModels.ChineseV3.ClassifierModel; // Version-specific
var recModel = LocalFullModels.ChineseV3.RecognitionModel; // Version-specific

var ocr = new PaddleOcrAll(detModel, clsModel, recModel);
// If a newer model format is released, these names and classes may change

' Simplified — see Sdcb.PaddleOCR documentation for full API
' This is not one line of setup; it represents several coordinated decisions:
' - Which model version to use (ChineseV3, V4, etc.)
' - Whether models are local files or downloaded on first use
' - Which inference backend (CPU, MKL, GPU)
' - Which OpenCvSharp runtime package matches the deployment OS

Dim detModel = LocalFullModels.ChineseV3.DetectionModel  ' Version-specific
Dim clsModel = LocalFullModels.ChineseV3.ClassifierModel ' Version-specific
Dim recModel = LocalFullModels.ChineseV3.RecognitionModel ' Version-specific

Dim ocr As New PaddleOcrAll(detModel, clsModel, recModel)
' If a newer model format is released, these names and classes may change

' Simplified — see Sdcb.PaddleOCR documentation for full API
' This is not one line of setup; it represents several coordinated decisions:
' - Which model version to use (ChineseV3, V4, etc.)
' - Whether models are local files or downloaded on first use
' - Which inference backend (CPU, MKL, GPU)
' - Which OpenCvSharp runtime package matches the deployment OS

Dim detModel = LocalFullModels.ChineseV3.DetectionModel  ' Version-specific
Dim clsModel = LocalFullModels.ChineseV3.ClassifierModel ' Version-specific
Dim recModel = LocalFullModels.ChineseV3.RecognitionModel ' Version-specific

Dim ocr As New PaddleOcrAll(detModel, clsModel, recModel)
' If a newer model format is released, these names and classes may change

The version sensitivity here is real. Teams that have pinned to Sdcb.PaddleOCR 2.x and need to upgrade to access newer models face API changes at the binding layer. The upstream model files are not backward-compatible between major PaddleOCR releases.

IronOCR Approach

IronOCR ships the engine and all dependencies bundled inside the NuGet package. There is no model version to select, no inference backend to configure, and no secondary library to keep synchronized:

// One package: dotnet add package IronOcr
// No model downloads. No OpenCV. No runtime packages.
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";

var result = new IronTesseract().Read("document.jpg");
Console.WriteLine(result.Text);
Console.WriteLine($"Confidence: {result.Confidence}%");

// One package: dotnet add package IronOcr
// No model downloads. No OpenCV. No runtime packages.
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";

var result = new IronTesseract().Read("document.jpg");
Console.WriteLine(result.Text);
Console.WriteLine($"Confidence: {result.Confidence}%");

Imports IronOcr

' One package: dotnet add package IronOcr
' No model downloads. No OpenCV. No runtime packages.
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY"

Dim result = New IronTesseract().Read("document.jpg")
Console.WriteLine(result.Text)
Console.WriteLine($"Confidence: {result.Confidence}%")

Imports IronOcr

' One package: dotnet add package IronOcr
' No model downloads. No OpenCV. No runtime packages.
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY"

Dim result = New IronTesseract().Read("document.jpg")
Console.WriteLine(result.Text)
Console.WriteLine($"Confidence: {result.Confidence}%")

Upgrading IronOCR is a single NuGet version bump. The API surface changes are documented in release notes, and backward compatibility within major versions is maintained. For teams working in CI/CD pipelines, the difference in deployment surface area is substantial: one package versus four packages plus platform-specific runtime packages plus model files that must exist on disk at the right paths.

See the IronTesseract setup guide for configuration options and the image input how-to for a full list of accepted input sources.

Language Coverage

PaddleOCR was trained primarily for Chinese, with English as a secondary language. The .NET community around PaddleSharp reflects that origin: model packs for Chinese script (Simplified, Traditional), English, and a handful of other languages exist, but coverage beyond approximately 10-20 languages is thin, and maintenance of non-CJK models depends on whether the upstream project sustains interest.

PaddleSharp Approach

Switching languages in PaddleSharp means switching the model set. The recognition model is language-specific, and there is no simple API flag - you instantiate a different set of model objects:

// Simplified — see Sdcb.PaddleOCR documentation for full API
// English model set (if available for your version)
// var recModel = LocalFullModels.EnglishV3.RecognitionModel;

// Chinese model set (primary supported use case)
var detModel = LocalFullModels.ChineseV3.DetectionModel;
var recModel = LocalFullModels.ChineseV3.RecognitionModel;
var clsModel = LocalFullModels.ChineseV3.ClassifierModel;

var ocr = new PaddleOcrAll(detModel, clsModel, recModel);
// Non-CJK languages require checking upstream PaddleOCR model availability
// Mixed CJK + Latin in the same document may require model selection decisions

// Simplified — see Sdcb.PaddleOCR documentation for full API
// English model set (if available for your version)
// var recModel = LocalFullModels.EnglishV3.RecognitionModel;

// Chinese model set (primary supported use case)
var detModel = LocalFullModels.ChineseV3.DetectionModel;
var recModel = LocalFullModels.ChineseV3.RecognitionModel;
var clsModel = LocalFullModels.ChineseV3.ClassifierModel;

var ocr = new PaddleOcrAll(detModel, clsModel, recModel);
// Non-CJK languages require checking upstream PaddleOCR model availability
// Mixed CJK + Latin in the same document may require model selection decisions

' Simplified — see Sdcb.PaddleOCR documentation for full API
' English model set (if available for your version)
' Dim recModel = LocalFullModels.EnglishV3.RecognitionModel

' Chinese model set (primary supported use case)
Dim detModel = LocalFullModels.ChineseV3.DetectionModel
Dim recModel = LocalFullModels.ChineseV3.RecognitionModel
Dim clsModel = LocalFullModels.ChineseV3.ClassifierModel

Dim ocr = New PaddleOcrAll(detModel, clsModel, recModel)
' Non-CJK languages require checking upstream PaddleOCR model availability
' Mixed CJK + Latin in the same document may require model selection decisions

' Simplified — see Sdcb.PaddleOCR documentation for full API
' English model set (if available for your version)
' Dim recModel = LocalFullModels.EnglishV3.RecognitionModel

' Chinese model set (primary supported use case)
Dim detModel = LocalFullModels.ChineseV3.DetectionModel
Dim recModel = LocalFullModels.ChineseV3.RecognitionModel
Dim clsModel = LocalFullModels.ChineseV3.ClassifierModel

Dim ocr = New PaddleOcrAll(detModel, clsModel, recModel)
' Non-CJK languages require checking upstream PaddleOCR model availability
' Mixed CJK + Latin in the same document may require model selection decisions

For a team processing French invoices, German contracts, or Arabic forms, the question is not just whether a model pack exists today - it is whether it will be maintained next year, and whether the English documentation to configure it exists.

IronOCR Approach

IronOCR delivers 125+ languages as NuGet packages. Each language pack installs exactly like any other dependency and integrates with standard CI/CD pipelines without manual file deployment:

// dotnet add package IronOcr.Languages.ChineseSimplified
// dotnet add package IronOcr.Languages.French
// dotnet add package IronOcr.Languages.Arabic

var ocr = new IronTesseract();
ocr.Language = OcrLanguage.ChineseSimplified;
ocr.AddSecondaryLanguage(OcrLanguage.English); // Mixed-language document

var result = ocr.Read("mixed-document.jpg");

// dotnet add package IronOcr.Languages.ChineseSimplified
// dotnet add package IronOcr.Languages.French
// dotnet add package IronOcr.Languages.Arabic

var ocr = new IronTesseract();
ocr.Language = OcrLanguage.ChineseSimplified;
ocr.AddSecondaryLanguage(OcrLanguage.English); // Mixed-language document

var result = ocr.Read("mixed-document.jpg");

' dotnet add package IronOcr.Languages.ChineseSimplified
' dotnet add package IronOcr.Languages.French
' dotnet add package IronOcr.Languages.Arabic

Dim ocr As New IronTesseract()
ocr.Language = OcrLanguage.ChineseSimplified
ocr.AddSecondaryLanguage(OcrLanguage.English) ' Mixed-language document

Dim result = ocr.Read("mixed-document.jpg")

' dotnet add package IronOcr.Languages.ChineseSimplified
' dotnet add package IronOcr.Languages.French
' dotnet add package IronOcr.Languages.Arabic

Dim ocr As New IronTesseract()
ocr.Language = OcrLanguage.ChineseSimplified
ocr.AddSecondaryLanguage(OcrLanguage.English) ' Mixed-language document

Dim result = ocr.Read("mixed-document.jpg")

The multiple language guide covers simultaneous multi-language recognition for documents that mix scripts - a capability that requires no model-level decision at all, just an AddSecondaryLanguage call.

For teams whose documents span multiple languages, or whose language requirements are expected to grow beyond the initial scope, a 125-language catalog backed by maintained NuGet packages is a more durable choice than a 10-20 language set with variable maintenance commitment.

Preprocessing and PDF Support

PaddleOCR's neural network pipeline handles some image quality variation better than traditional OCR for CJK text, but it provides no built-in image preprocessing API for tasks like deskewing, noise removal, or resolution normalization. Any preprocessing must be written in OpenCV - a library that PaddleSharp already requires but that adds significant code surface for teams that are not image processing specialists.

PDF support is the harder gap. PaddleSharp has no native PDF reader. A document pipeline that receives PDFs must convert each page to an image before calling the OCR engine, which requires a separate PDF library, adds dependencies, and introduces intermediate file management.

PaddleSharp Approach

// Simplified — see Sdcb.PaddleOCR documentation for full API
// PaddleSharp has no PDF support — pages must be pre-converted to images
// Preprocessing (deskew, denoise) requires OpenCV operations:

using OpenCvSharp;

// Load image via OpenCV
using var image = Cv2.ImRead("scan.jpg");

// Manual grayscale conversion
using var gray = new Mat();
Cv2.CvtColor(image, gray, ColorConversionCodes.BGR2GRAY);

// Manual threshold (binarization)
using var binary = new Mat();
Cv2.Threshold(gray, binary, 128, 255, ThresholdTypes.Binary);

// Then pass to OCR engine
var result = _ocr.Run(binary);
// Each preprocessing step requires OpenCV knowledge
// PDF pages require a separate PDF-to-image conversion step first

// Simplified — see Sdcb.PaddleOCR documentation for full API
// PaddleSharp has no PDF support — pages must be pre-converted to images
// Preprocessing (deskew, denoise) requires OpenCV operations:

using OpenCvSharp;

// Load image via OpenCV
using var image = Cv2.ImRead("scan.jpg");

// Manual grayscale conversion
using var gray = new Mat();
Cv2.CvtColor(image, gray, ColorConversionCodes.BGR2GRAY);

// Manual threshold (binarization)
using var binary = new Mat();
Cv2.Threshold(gray, binary, 128, 255, ThresholdTypes.Binary);

// Then pass to OCR engine
var result = _ocr.Run(binary);
// Each preprocessing step requires OpenCV knowledge
// PDF pages require a separate PDF-to-image conversion step first

Imports OpenCvSharp

' Load image via OpenCV
Using image As Mat = Cv2.ImRead("scan.jpg")

    ' Manual grayscale conversion
    Using gray As New Mat()
        Cv2.CvtColor(image, gray, ColorConversionCodes.BGR2GRAY)

        ' Manual threshold (binarization)
        Using binary As New Mat()
            Cv2.Threshold(gray, binary, 128, 255, ThresholdTypes.Binary)

            ' Then pass to OCR engine
            Dim result = _ocr.Run(binary)
            ' Each preprocessing step requires OpenCV knowledge
            ' PDF pages require a separate PDF-to-image conversion step first
        End Using
    End Using
End Using

Imports OpenCvSharp

' Load image via OpenCV
Using image As Mat = Cv2.ImRead("scan.jpg")

    ' Manual grayscale conversion
    Using gray As New Mat()
        Cv2.CvtColor(image, gray, ColorConversionCodes.BGR2GRAY)

        ' Manual threshold (binarization)
        Using binary As New Mat()
            Cv2.Threshold(gray, binary, 128, 255, ThresholdTypes.Binary)

            ' Then pass to OCR engine
            Dim result = _ocr.Run(binary)
            ' Each preprocessing step requires OpenCV knowledge
            ' PDF pages require a separate PDF-to-image conversion step first
        End Using
    End Using
End Using

Writing this preprocessing is feasible for teams with OpenCV experience. For teams without it, the learning curve is non-trivial - OpenCV has a broad API surface and the documentation is largely C++ first.

IronOCR Approach

IronOCR's preprocessing pipeline requires no external library. The same OcrInput object that accepts images also accepts PDFs, and preprocessing filters are single method calls:

using var input = new OcrInput();
input.LoadImage("low-quality-scan.jpg");

// Built-in preprocessing — no OpenCV, no manual image math
input.Deskew();
input.DeNoise();
input.Contrast();
input.Binarize();
input.EnhanceResolution(300);

var result = new IronTesseract().Read(input);
Console.WriteLine(result.Text);

using var input = new OcrInput();
input.LoadImage("low-quality-scan.jpg");

// Built-in preprocessing — no OpenCV, no manual image math
input.Deskew();
input.DeNoise();
input.Contrast();
input.Binarize();
input.EnhanceResolution(300);

var result = new IronTesseract().Read(input);
Console.WriteLine(result.Text);

Imports IronOcr

Using input As New OcrInput()
    input.LoadImage("low-quality-scan.jpg")

    ' Built-in preprocessing — no OpenCV, no manual image math
    input.Deskew()
    input.DeNoise()
    input.Contrast()
    input.Binarize()
    input.EnhanceResolution(300)

    Dim result = New IronTesseract().Read(input)
    Console.WriteLine(result.Text)
End Using

Imports IronOcr

Using input As New OcrInput()
    input.LoadImage("low-quality-scan.jpg")

    ' Built-in preprocessing — no OpenCV, no manual image math
    input.Deskew()
    input.DeNoise()
    input.Contrast()
    input.Binarize()
    input.EnhanceResolution(300)

    Dim result = New IronTesseract().Read(input)
    Console.WriteLine(result.Text)
End Using

For PDF input, native support means no conversion step:

// PDF input — no external library, no page conversion
var result = new IronTesseract().Read("scanned-document.pdf");

// Password-protected PDFs
using var input = new OcrInput();
input.LoadPdf("encrypted.pdf", Password: "secret");
var result = new IronTesseract().Read(input);

// Output as searchable PDF
result.SaveAsSearchablePdf("searchable-output.pdf");

// PDF input — no external library, no page conversion
var result = new IronTesseract().Read("scanned-document.pdf");

// Password-protected PDFs
using var input = new OcrInput();
input.LoadPdf("encrypted.pdf", Password: "secret");
var result = new IronTesseract().Read(input);

// Output as searchable PDF
result.SaveAsSearchablePdf("searchable-output.pdf");

Imports IronTesseract

' PDF input — no external library, no page conversion
Dim result = New IronTesseract().Read("scanned-document.pdf")

' Password-protected PDFs
Using input As New OcrInput()
    input.LoadPdf("encrypted.pdf", Password:="secret")
    result = New IronTesseract().Read(input)
End Using

' Output as searchable PDF
result.SaveAsSearchablePdf("searchable-output.pdf")

Imports IronTesseract

' PDF input — no external library, no page conversion
Dim result = New IronTesseract().Read("scanned-document.pdf")

' Password-protected PDFs
Using input As New OcrInput()
    input.LoadPdf("encrypted.pdf", Password:="secret")
    result = New IronTesseract().Read(input)
End Using

' Output as searchable PDF
result.SaveAsSearchablePdf("searchable-output.pdf")

The image quality correction guide covers all available filters with examples. The PDF input how-to covers page selection, stream input, and password handling. For teams producing searchable PDFs from scanned documents, searchable PDF output is a built-in output format - not a separate processing step.

API Mapping Reference

When Teams Consider Moving from PaddleSharp OCR to IronOCR

The Pipeline Processes Non-CJK Documents

PaddleSharp was built for Chinese. That heritage is visible in the model naming convention (ChineseV3), the primary documentation language, and the language pack availability. A team that starts with Chinese document processing and then expands to French invoices or German contracts hits a hard wall: the available model packs outside CJK are few, the maintenance commitment for non-CJK models is uncertain, and the English-language documentation for setting them up is sparse. IronOCR's 125+ language catalog via NuGet means language expansion is a package install, not a research project.

The Deployment Environment Has No GPU

PaddleOCR's deep learning pipeline is designed for GPU inference. On CPU, the performance numbers are honest: 500-1500ms per image at typical document resolutions. For a batch pipeline processing thousands of documents, or for an ASP.NET application serving concurrent OCR requests, CPU-mode PaddleSharp adds latency that compounds across scale. IronOCR's optimized Tesseract 5 engine runs at 100-400ms per image on CPU with no GPU requirement. For deployments on standard VM tiers, containers without GPU pass-through, or CI workers, that difference is the difference between a workload that fits and one that does not.

PDF Documents Are in the Input Pipeline

PDF is the format of record for business documents. PaddleSharp has no PDF reader. Teams that discover this limitation after building around PaddleSharp face a choice: add a PDF library (now managing yet another dependency with its own licensing and version considerations), convert PDFs to images as a preprocessing step (adding storage and I/O overhead), or migrate to a library with native PDF support. IronOCR's native PDF input, including password-protected PDFs and page-range selection, makes it the straightforward choice for document workflows that start with PDF.

The Dependency Chain Fails a Security or Compliance Review

Enterprise deployments - healthcare, finance, government - often require a software bill of materials and dependency audit. PaddleSharp's chain includes Baidu-originated model files and a Baidu deep learning inference runtime. For organizations with policies restricting software components to specific origins, or for teams that need a clear path to vendor security disclosures, a dependency on Baidu-origin binaries requires additional review steps. IronOCR is a single commercial product from a Western software vendor with documented licensing terms and a standard commercial support engagement.

The Team Cannot Staff the Operational Overhead

Maintaining a PaddleSharp deployment over 18 months means tracking model version compatibility, coordinating OpenCV runtime package versions with platform-specific deployments, keeping CUDA toolkit versions aligned if GPU is in use, and monitoring the upstream GitHub issues (primarily in Chinese) for breaking changes. That is a non-trivial operational investment. For teams whose core competency is the application they are building - not deep learning infrastructure - the overhead of managing PaddleSharp does not produce value proportional to its cost.

Common Migration Considerations

Removing the OpenCV Dependency

PaddleSharp requires OpenCvSharp4 and a platform-specific OpenCvSharp4.runtime.* package for image loading. IronOCR accepts System.Drawing.Bitmap, file paths, streams, and byte arrays directly through OcrInput. Migration means replacing Cv2.ImRead() calls with input.LoadImage() and removing the OpenCvSharp package references entirely:

// PaddleSharp pattern — requires OpenCV
using var image = Cv2.ImRead(imagePath);
var result = _ocr.Run(image);

// IronOCR equivalent — no OpenCV
var result = new IronTesseract().Read(imagePath);

// PaddleSharp pattern — requires OpenCV
using var image = Cv2.ImRead(imagePath);
var result = _ocr.Run(image);

// IronOCR equivalent — no OpenCV
var result = new IronTesseract().Read(imagePath);

Imports OpenCvSharp
Imports IronOcr

' PaddleSharp pattern — requires OpenCV
Using image As Mat = Cv2.ImRead(imagePath)
    Dim result = _ocr.Run(image)
End Using

' IronOCR equivalent — no OpenCV
Dim result = New IronTesseract().Read(imagePath)

Imports OpenCvSharp
Imports IronOcr

' PaddleSharp pattern — requires OpenCV
Using image As Mat = Cv2.ImRead(imagePath)
    Dim result = _ocr.Run(image)
End Using

' IronOCR equivalent — no OpenCV
Dim result = New IronTesseract().Read(imagePath)

The image input guide covers all accepted input types including streams, URLs, and in-memory bitmaps.

Region-Level Result Mapping

PaddleSharp returns result.Regions - a flat list of detected text regions with bounding rectangles and text strings. IronOCR returns a richer hierarchy: pages contain paragraphs, paragraphs contain lines, lines contain words, all with coordinates and per-element confidence scores. If your migration code uses result.Regions, the IronOCR equivalent for flat word enumeration with position data is:

var result = new IronTesseract().Read("document.jpg");

// Per-word with position — equivalent to PaddleSharp region enumeration
foreach (var word in result.Words)
{
    Console.WriteLine($"'{word.Text}' at ({word.X},{word.Y}) confidence:{word.Confidence}%");
}

var result = new IronTesseract().Read("document.jpg");

// Per-word with position — equivalent to PaddleSharp region enumeration
foreach (var word in result.Words)
{
    Console.WriteLine($"'{word.Text}' at ({word.X},{word.Y}) confidence:{word.Confidence}%");
}

Imports System
Imports IronOcr

Dim result = New IronTesseract().Read("document.jpg")

' Per-word with position — equivalent to PaddleSharp region enumeration
For Each word In result.Words
    Console.WriteLine($"'{word.Text}' at ({word.X},{word.Y}) confidence:{word.Confidence}%")
Next

Imports System
Imports IronOcr

Dim result = New IronTesseract().Read("document.jpg")

' Per-word with position — equivalent to PaddleSharp region enumeration
For Each word In result.Words
    Console.WriteLine($"'{word.Text}' at ({word.X},{word.Y}) confidence:{word.Confidence}%")
Next

The read results guide documents the full result structure. The confidence scores guide explains per-element confidence values and how to use them for quality filtering.

Lifecycle Management for the OCR Engine

PaddleSharp's PaddleOcrAll is expensive to construct - it loads model binaries from disk on creation and should be treated as a singleton or scoped service in ASP.NET Core. IronOCR's IronTesseract has a lighter initialization cost, but the same principle applies: reusing instances across requests in a web application is more efficient than constructing per-request. In both cases, dependency injection as a singleton or per-request scoped service is the correct pattern.

Language Pack Installation

PaddleSharp language support means selecting different model sets at construction time. In IronOCR, language support is a NuGet package added to the project and a one-line configuration call:

// dotnet add package IronOcr.Languages.ChineseSimplified

var ocr = new IronTesseract();
ocr.Language = OcrLanguage.ChineseSimplified;
var result = ocr.Read("document.jpg");

// dotnet add package IronOcr.Languages.ChineseSimplified

var ocr = new IronTesseract();
ocr.Language = OcrLanguage.ChineseSimplified;
var result = ocr.Read("document.jpg");

Imports IronOcr

Dim ocr As New IronTesseract()
ocr.Language = OcrLanguage.ChineseSimplified
Dim result = ocr.Read("document.jpg")

Imports IronOcr

Dim ocr As New IronTesseract()
ocr.Language = OcrLanguage.ChineseSimplified
Dim result = ocr.Read("document.jpg")

For CJK teams migrating from PaddleSharp, Chinese Simplified, Chinese Traditional, Japanese, and Korean are all available as IronOCR language packs. The custom language guide covers bringing in custom-trained tessdata for specialized use cases.

Additional IronOCR Capabilities

Beyond the features compared above, IronOCR provides capabilities that fall entirely outside PaddleSharp's scope:

• Region-based OCR: Target specific zones of an image - header rows, invoice totals, specific form fields - using CropRectangle without processing the full page
• Async OCR: Built-in async support for integrating OCR into ASP.NET Core request pipelines without blocking threads
• Passport and ID reading: Structured extraction of machine-readable zone data from travel documents and identity cards
• Table reading: Spatial grouping of word coordinates to reconstruct row-column structure from tabular document layouts
• Licensing: Perpetual per-developer licenses with no runtime royalties and free development use under the trial mode

.NET Compatibility and Future Readiness

IronOCR targets .NET 8 and .NET 9 with full support for Windows, Linux, and macOS across x64 and x86 architectures, and publishes Docker deployment guides for containerized workloads. PaddleSharp supports modern .NET runtimes but its cross-platform story is complicated by the OpenCV runtime packages, which are distributed as separate platform-specific NuGet packages requiring the correct one to be selected and deployed per environment. IronOCR's single-package deployment model eliminates this platform matrix entirely, and its Linux, AWS, and Azure deployment guides reflect tested, production-facing configurations.

Conclusion

PaddleSharp makes a compelling argument in one narrow scenario: a team processing predominantly Chinese documents on hardware with a CUDA-capable GPU, where the deep learning accuracy ceiling for CJK text is more important than deployment simplicity. That is a real use case, and within it, PaddleSharp delivers. The three-stage neural network pipeline does recognize dense Chinese text with accuracy that reflects genuine deep learning investment.

Outside that scenario, the abstraction depth becomes a liability. Three upstream dependencies - Baidu's inference framework, the PaddleOCR model training project, and the PaddleSharp .NET binding layer - each carry their own release cycles, and their maintenance alignment is not guaranteed. The English-language documentation is sparse. The language catalog beyond CJK is thin and inconsistently maintained. PDF input requires a separate library. And without a GPU, per-image CPU latency is 500-1500ms against IronOCR's 100-400ms.

IronOCR's trade-off is the inverse: a single commercial package with a $999 entry price, no model management, native PDF and multi-format input, 125+ languages as NuGet packages, and built-in preprocessing that eliminates the need for OpenCV. The abstraction is by design, and the abstraction is stable - the API has not required teams to track upstream Baidu model format changes to keep their applications running.

For teams with general-purpose English or multi-language OCR needs, PDF workflows, or deployment constraints that preclude GPU hardware, IronOCR is the straightforward choice. The IronOCR documentation covers the full range of input types, preprocessing options, and output formats, and the tutorials hub provides working code for common document types from invoices to passports to scanned archives.