Tesseract .NET SDK (official) vs IronOCR: .NET

Legacy .NET Framework Targeting in Practice

The hard boundary at .NET Framework 4.5 is not just a checkbox — it shapes every architectural decision downstream. A project that depends on Tesseract.Net.SDK cannot target <TargetFramework>net8.0</TargetFramework> in its .csproj. It cannot be built by a GitHub Actions runner using mcr.microsoft.com/dotnet/sdk:8.0. It cannot be deployed to a Kubernetes pod running a Linux container. The moment the rest of the organization moves past that line, the OCR service becomes an orphan.

The SDK's own initialization code exposes this directly. The basic usage pattern in tesseract-net-sdk-basic-ocr.cs includes an explicit Windows platform guard:

// Install: Install-Package Tesseract.Net.SDK
// Platform: Windows ONLY (.NET Framework 2.0-4.5)
using Patagames.Ocr;

public string ExtractTextSimple(string imagePath)
{
    // Platform check — Tesseract.Net.SDK is Windows-only
    if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
    {
        throw new PlatformNotSupportedException(
            "Tesseract.Net.SDK only supports Windows.");
    }

    // Verify tessdata exists
    if (!Directory.Exists(@".\tessdata"))
    {
        throw new DirectoryNotFoundException(
            "tessdata folder not found. Download traineddata files from GitHub.");
    }

    using (var api = OcrApi.Create())
    {
        api.Init(Languages.English);       // loads eng.traineddata (~40 MB)
        return api.GetTextFromImage(imagePath);
    }
}

// Install: Install-Package Tesseract.Net.SDK
// Platform: Windows ONLY (.NET Framework 2.0-4.5)
using Patagames.Ocr;

public string ExtractTextSimple(string imagePath)
{
    // Platform check — Tesseract.Net.SDK is Windows-only
    if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
    {
        throw new PlatformNotSupportedException(
            "Tesseract.Net.SDK only supports Windows.");
    }

    // Verify tessdata exists
    if (!Directory.Exists(@".\tessdata"))
    {
        throw new DirectoryNotFoundException(
            "tessdata folder not found. Download traineddata files from GitHub.");
    }

    using (var api = OcrApi.Create())
    {
        api.Init(Languages.English);       // loads eng.traineddata (~40 MB)
        return api.GetTextFromImage(imagePath);
    }
}

Imports Patagames.Ocr
Imports System.Runtime.InteropServices
Imports System.IO

Public Function ExtractTextSimple(ByVal imagePath As String) As String
    ' Platform check — Tesseract.Net.SDK is Windows-only
    If Not RuntimeInformation.IsOSPlatform(OSPlatform.Windows) Then
        Throw New PlatformNotSupportedException("Tesseract.Net.SDK only supports Windows.")
    End If

    ' Verify tessdata exists
    If Not Directory.Exists(".\tessdata") Then
        Throw New DirectoryNotFoundException("tessdata folder not found. Download traineddata files from GitHub.")
    End If

    Using api = OcrApi.Create()
        api.Init(Languages.English) ' loads eng.traineddata (~40 MB)
        Return api.GetTextFromImage(imagePath)
    End Using
End Function

Two defensive checks appear before a single line of OCR work: confirm Windows, confirm tessdata. On any non-Windows host, the method throws before reaching the engine. On any machine where the tessdata folder was not copied during deployment, it throws again. Neither check is boilerplate — both represent failure modes that developers encounter in production.

Detailed Feature Comparison

Tesseract.Net.SDK Approach

Tesseract.Net.SDK targets .NET Framework 2.0 through 4.5. Every project that depends on it must itself target one of those framework versions. The migration comparison file confirms this constraint in the setup section:

// Install: Install-Package Tesseract.Net.SDK
// License: Commercial (Patagames)
// Platform: Windows ONLY (.NET Framework 2.0-4.5)
//
// Requirements:
//   - tessdata folder must exist in bin/Debug/ or bin/Release/
//   - Download traineddata files from https://github.com/tesseract-ocr/tessdata
//   - Windows operating system (no Linux/macOS support)

using Patagames.Ocr;

// Multi-language setup — all traineddata files must be manually downloaded
using (var api = OcrApi.Create())
{
    // Combine languages with bitwise OR
    api.Init(Languages.English | Languages.German | Languages.French);

    string text = api.GetTextFromImage(imagePath);
    return text;
}

// Install: Install-Package Tesseract.Net.SDK
// License: Commercial (Patagames)
// Platform: Windows ONLY (.NET Framework 2.0-4.5)
//
// Requirements:
//   - tessdata folder must exist in bin/Debug/ or bin/Release/
//   - Download traineddata files from https://github.com/tesseract-ocr/tessdata
//   - Windows operating system (no Linux/macOS support)

using Patagames.Ocr;

// Multi-language setup — all traineddata files must be manually downloaded
using (var api = OcrApi.Create())
{
    // Combine languages with bitwise OR
    api.Init(Languages.English | Languages.German | Languages.French);

    string text = api.GetTextFromImage(imagePath);
    return text;
}

Imports Patagames.Ocr

' Install: Install-Package Tesseract.Net.SDK
' License: Commercial (Patagames)
' Platform: Windows ONLY (.NET Framework 2.0-4.5)
'
' Requirements:
'   - tessdata folder must exist in bin/Debug/ or bin/Release/
'   - Download traineddata files from https://github.com/tesseract-ocr/tessdata
'   - Windows operating system (no Linux/macOS support)

' Multi-language setup — all traineddata files must be manually downloaded
Using api = OcrApi.Create()
    ' Combine languages with bitwise OR
    api.Init(Languages.English Or Languages.German Or Languages.French)

    Dim text As String = api.GetTextFromImage(imagePath)
    Return text
End Using

The using (var api = OcrApi.Create()) pattern is idiomatic .NET Framework 2.0. It uses the C# 1.0 using statement rather than the C# 8.0 using var declaration. The namespace is Patagames.Ocr. The language combination uses bitwise OR on an enum. None of this code compiles against a net6.0 or net8.0 target framework in an SDK-style project file, because Tesseract.Net.SDK itself does not produce a compatible assembly.

Teams stuck on .NET Framework 4.5 are not stuck there by preference. They are there because dependencies — sometimes including an OCR library — cannot be upgraded. Choosing Tesseract.Net.SDK deepens that dependency chain.

IronOCR Approach

IronOCR supports .NET Framework 4.6.2 and every modern .NET runtime through .NET 9. The same package binary runs on all of them. Upgrading a project from .NET Framework 4.8 to .NET 8 does not require replacing the OCR library.

// Works on .NET Framework 4.6.2, .NET Core, .NET 5/6/7/8/9
// Same NuGet package, same API, same results
using IronOcr;

IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";

var ocr = new IronTesseract();
ocr.Language = OcrLanguage.English;
ocr.AddSecondaryLanguage(OcrLanguage.German);
ocr.AddSecondaryLanguage(OcrLanguage.French);

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

// Works on .NET Framework 4.6.2, .NET Core, .NET 5/6/7/8/9
// Same NuGet package, same API, same results
using IronOcr;

IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";

var ocr = new IronTesseract();
ocr.Language = OcrLanguage.English;
ocr.AddSecondaryLanguage(OcrLanguage.German);
ocr.AddSecondaryLanguage(OcrLanguage.French);

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

Imports IronOcr

' Works on .NET Framework 4.6.2, .NET Core, .NET 5/6/7/8/9
' Same NuGet package, same API, same results

IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY"

Dim ocr As New IronTesseract()
ocr.Language = OcrLanguage.English
ocr.AddSecondaryLanguage(OcrLanguage.German)
ocr.AddSecondaryLanguage(OcrLanguage.French)

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

No bitwise OR on language enums. No tessdata folder. No platform check. The IronTesseract setup guide covers configuration options for all supported runtimes in a single document.

The practical consequence for teams mid-migration: an ASP.NET Core 8 project and a legacy .NET Framework 4.8 project can share the same IronOCR service layer. No conditional compilation, no separate library versions, no abstraction layer to paper over incompatible APIs.

Tesseract.Net.SDK Approach

Tesseract.Net.SDK ships Windows x86 and x64 native binaries. The P/Invoke calls that initialize the Tesseract engine resolve to those Windows DLLs. On a Linux host — including any Docker container based on mcr.microsoft.com/dotnet/aspnet:8.0, ubuntu, or alpine — the DLL cannot be loaded, and the application throws DllNotFoundException at runtime.

The parallel processing example from tesseract-net-sdk-pdf-processing.cs illustrates what this means for batch workloads on Windows itself before even considering Linux:

// Windows-only: Parallel.ForEach with separate engine per thread
// Each engine loads ~40-100 MB per language
Parallel.ForEach(
    imagePaths,
    new ParallelOptions { MaxDegreeOfParallelism = 4 },
    imagePath =>
    {
        // WARNING: Must create separate OcrApi for each thread!
        // Memory usage: 4 threads × 100MB = 400MB minimum
        using (var api = OcrApi.Create())
        {
            api.Init(Languages.English);
            string text = api.GetTextFromImage(imagePath);
            results[imagePath] = text;
        }
    });

// Windows-only: Parallel.ForEach with separate engine per thread
// Each engine loads ~40-100 MB per language
Parallel.ForEach(
    imagePaths,
    new ParallelOptions { MaxDegreeOfParallelism = 4 },
    imagePath =>
    {
        // WARNING: Must create separate OcrApi for each thread!
        // Memory usage: 4 threads × 100MB = 400MB minimum
        using (var api = OcrApi.Create())
        {
            api.Init(Languages.English);
            string text = api.GetTextFromImage(imagePath);
            results[imagePath] = text;
        }
    });

Four parallel threads, four engine instances, 400 MB of language data loaded simultaneously — and this is for English alone. Add German and French and that baseline doubles. The SDK offers no pooling mechanism to mitigate this. The architecture is incompatible with modern container resource limits, which typically enforce memory ceilings per pod.

There is also no path to Azure Functions on a Linux Consumption Plan, no path to AWS Lambda (which runs on Amazon Linux), and no path to Google Cloud Run. Every major serverless platform defaults to Linux. Tesseract.Net.SDK is excluded from all of them by design.

IronOCR Approach

IronOCR deploys to Docker without additional configuration beyond a single apt-get line for libgdiplus on Debian-based images. The Docker deployment guide covers both Linux and Windows containers. The same holds for Linux deployments, Azure, and AWS.

Thread safety is built into IronTesseract. One instance services all parallel workers:

// Cross-platform: Windows, Linux, macOS, Docker
// Single instance — thread-safe
using IronOcr;

var ocr = new IronTesseract();

// Single engine instance shared across all threads
// No memory multiplication
Parallel.ForEach(imagePaths, imagePath =>
{
    using var input = new OcrInput();
    input.LoadImage(imagePath);
    var result = ocr.Read(input);
    SaveResult(imagePath, result.Text);
});

// Cross-platform: Windows, Linux, macOS, Docker
// Single instance — thread-safe
using IronOcr;

var ocr = new IronTesseract();

// Single engine instance shared across all threads
// No memory multiplication
Parallel.ForEach(imagePaths, imagePath =>
{
    using var input = new OcrInput();
    input.LoadImage(imagePath);
    var result = ocr.Read(input);
    SaveResult(imagePath, result.Text);
});

Imports IronOcr

' Cross-platform: Windows, Linux, macOS, Docker
' Single instance — thread-safe
Dim ocr As New IronTesseract()

' Single engine instance shared across all threads
' No memory multiplication
Parallel.ForEach(imagePaths, Sub(imagePath)
    Using input As New OcrInput()
        input.LoadImage(imagePath)
        Dim result = ocr.Read(input)
        SaveResult(imagePath, result.Text)
    End Using
End Sub)

Four threads, one engine instance, one copy of language data in memory. For a multithreading example with throughput benchmarks, the IronOCR documentation covers the configuration options in detail.

Tesseract.Net.SDK Approach

Tesseract.Net.SDK has no PDF support. The tesseract-net-sdk-pdf-processing.cs file is candid about this limitation in its header:

// CRITICAL LIMITATION:
// Tesseract.Net.SDK does NOT support PDF input natively.
// You must use a separate library to convert PDF pages to images first.
// This example uses PdfiumViewer, but alternatives include:
//   - iTextSharp
//   - Ghostscript.NET
//   - Docnet.Core

The result is a multi-library pipeline. Install PdfiumViewer. Render each PDF page to a Bitmap at 200–300 DPI. Write that bitmap to a temporary file. Run api.GetTextFromImage() on the temp file. Delete the temp file. Repeat for every page. Implement error handling for partial failures mid-document. Manage memory explicitly — the ProcessLargeTiff example forces GC.Collect() every ten pages to prevent out-of-memory errors on large documents.

That is the actual production code, not a simplified example. It runs only on Windows, only on .NET Framework, and it requires a second commercial or open-source dependency that itself needs deployment management.

IronOCR Approach

IronOCR reads PDFs natively. No secondary library, no temp files, no page-rendering loop:

// Native PDF OCR — no PdfiumViewer, no temp files
using IronOcr;

var ocr = new IronTesseract();

using var input = new OcrInput();
input.LoadPdf("scanned-report.pdf");   // native PDF support
var result = ocr.Read(input);

// Access page-by-page results
foreach (var page in result.Pages)
{
    Console.WriteLine($"Page {page.PageNumber}: {page.Text}");
}

// Or produce a searchable PDF output
result.SaveAsSearchablePdf("searchable-report.pdf");

// Native PDF OCR — no PdfiumViewer, no temp files
using IronOcr;

var ocr = new IronTesseract();

using var input = new OcrInput();
input.LoadPdf("scanned-report.pdf");   // native PDF support
var result = ocr.Read(input);

// Access page-by-page results
foreach (var page in result.Pages)
{
    Console.WriteLine($"Page {page.PageNumber}: {page.Text}");
}

// Or produce a searchable PDF output
result.SaveAsSearchablePdf("searchable-report.pdf");

Imports IronOcr

Dim ocr As New IronTesseract()

Using input As New OcrInput()
    input.LoadPdf("scanned-report.pdf") ' native PDF support
    Dim result = ocr.Read(input)

    ' Access page-by-page results
    For Each page In result.Pages
        Console.WriteLine($"Page {page.PageNumber}: {page.Text}")
    Next

    ' Or produce a searchable PDF output
    result.SaveAsSearchablePdf("searchable-report.pdf")
End Using

Password-protected PDFs require one additional parameter: input.LoadPdf("encrypted.pdf", Password: "secret"). Specific page ranges use input.LoadPdfPages("document.pdf", 1, 10). The PDF input guide and searchable PDF how-to cover all variants.

The PDF OCR example shows the full pattern including confidence checking and structured output. The searchable PDF example demonstrates the document archive use case where scanned PDFs become indexed and searchable.

Tesseract.Net.SDK Approach

Tesseract engines are sensitive to image quality. Documents that are skewed, low-resolution, or noisy produce significantly degraded output without preprocessing. Tesseract.Net.SDK offers none.

The migration comparison file quantifies the gap directly:

// Tesseract.Net.SDK: No preprocessing available
// Direct OCR on problematic image = garbage output
using (var api = OcrApi.Create())
{
    api.Init(Languages.English);

    // Direct OCR on problematic image — poor results
    string text = api.GetTextFromImage(imagePath);
    return text;

    // To preprocess, you need:
    // 1. Install Emgu CV or OpenCvSharp
    // 2. Implement Hough transform for skew detection
    // 3. Implement affine rotation for deskew
    // 4. Implement FastNlMeansDenoising for noise reduction
    // 5. Handle all the native OpenCV dependencies
    // This is often 200+ lines of code
}

// Tesseract.Net.SDK: No preprocessing available
// Direct OCR on problematic image = garbage output
using (var api = OcrApi.Create())
{
    api.Init(Languages.English);

    // Direct OCR on problematic image — poor results
    string text = api.GetTextFromImage(imagePath);
    return text;

    // To preprocess, you need:
    // 1. Install Emgu CV or OpenCvSharp
    // 2. Implement Hough transform for skew detection
    // 3. Implement affine rotation for deskew
    // 4. Implement FastNlMeansDenoising for noise reduction
    // 5. Handle all the native OpenCV dependencies
    // This is often 200+ lines of code
}

Imports Tesseract.Net.SDK

' Tesseract.Net.SDK: No preprocessing available
' Direct OCR on problematic image = garbage output
Using api = OcrApi.Create()
    api.Init(Languages.English)

    ' Direct OCR on problematic image — poor results
    Dim text As String = api.GetTextFromImage(imagePath)
    Return text

    ' To preprocess, you need:
    ' 1. Install Emgu CV or OpenCvSharp
    ' 2. Implement Hough transform for skew detection
    ' 3. Implement affine rotation for deskew
    ' 4. Implement FastNlMeansDenoising for noise reduction
    ' 5. Handle all the native OpenCV dependencies
    ' This is often 200+ lines of code
End Using

The comment is not hyperbole. A production-quality deskew implementation using OpenCV in .NET is 100–200 lines of initialization, angle detection, matrix computation, and affine transformation. That code must then be tested, maintained, and deployed — with its own native dependency chain that again only works on Windows.

IronOCR Approach

IronOCR bundles preprocessing as first-class API methods on OcrInput. The same operations that require an OpenCV integration in Tesseract.Net.SDK are single method calls here:

// Built-in preprocessing — no external library required
using IronOcr;

var ocr = new IronTesseract();

using var input = new OcrInput();
input.LoadImage("skewed-invoice-scan.jpg");

input.Deskew();               // automatic angle detection and correction
input.DeNoise();              // scanner artifact removal
input.Contrast();             // contrast enhancement
input.Binarize();             // optimal threshold conversion
input.EnhanceResolution(300); // scale low-DPI images to 300 DPI

var result = ocr.Read(input);
Console.WriteLine($"Confidence: {result.Confidence}%");

// Built-in preprocessing — no external library required
using IronOcr;

var ocr = new IronTesseract();

using var input = new OcrInput();
input.LoadImage("skewed-invoice-scan.jpg");

input.Deskew();               // automatic angle detection and correction
input.DeNoise();              // scanner artifact removal
input.Contrast();             // contrast enhancement
input.Binarize();             // optimal threshold conversion
input.EnhanceResolution(300); // scale low-DPI images to 300 DPI

var result = ocr.Read(input);
Console.WriteLine($"Confidence: {result.Confidence}%");

Imports IronOcr

Dim ocr As New IronTesseract()

Using input As New OcrInput()
    input.LoadImage("skewed-invoice-scan.jpg")

    input.Deskew()               ' automatic angle detection and correction
    input.DeNoise()              ' scanner artifact removal
    input.Contrast()             ' contrast enhancement
    input.Binarize()             ' optimal threshold conversion
    input.EnhanceResolution(300) ' scale low-DPI images to 300 DPI

    Dim result = ocr.Read(input)
    Console.WriteLine($"Confidence: {result.Confidence}%")
End Using

The image quality correction guide and image color correction guide document all available filters with before/after accuracy comparisons. The low quality scan example shows accuracy improvement numbers for typical real-world document conditions.

For scanned document workflows specifically, the scanned document processing guide covers orientation detection, multi-page handling, and batch throughput optimization in a single article.

The .NET Upgrade Forces the Issue

The most common trigger is not dissatisfaction with OCR quality — it is a planned .NET Framework upgrade hitting a hard stop at the OCR layer. A team upgrading a document management application from .NET Framework 4.7 to .NET 8 discovers that Tesseract.Net.SDK produces no compatible target framework assembly. The upgrade either stalls, or the OCR service gets isolated into a separate Windows-only process communicating over HTTP — which introduces a network hop, a separate deployment artifact, and a compatibility shim that must be maintained indefinitely. Neither outcome is acceptable for most teams on an active upgrade path. Replacing Tesseract.Net.SDK with IronOCR removes the blocker and allows the upgrade to proceed cleanly, because IronOCR runs on both the old .NET Framework 4.6.2+ and the new .NET 8 target simultaneously, meaning the service can be migrated incrementally.

Containerization of the Processing Pipeline

Document processing workloads are among the first candidates for containerization: they are stateless, CPU-bound, and benefit from horizontal scaling. A team that has containerized the rest of its pipeline discovers Tesseract.Net.SDK fails at the Docker image build step when the base image is Linux. The choices are Windows containers — which carry a licensing cost, larger image sizes, and incompatibility with most managed Kubernetes services that default to Linux node pools — or a library that actually supports Linux. IronOCR deploys to any Linux container with a standard Dockerfile. The Docker deployment guide provides the exact Dockerfile configuration for both Debian and Alpine base images.

Parallel Batch Processing at Scale

An invoice processing pipeline handling 50,000 documents per day with four parallel workers using Tesseract.Net.SDK allocates a minimum of 400 MB just for the four engine instances loaded with English data. Add a second language and that doubles. Add preprocessing via OpenCV and memory consumption climbs further. On a constrained server or a containerized deployment with a 2 GB memory limit per pod, this arithmetic becomes a deployment blocker. IronOCR's thread-safe single-instance model eliminates the per-thread memory multiplication. One engine instance handles four, eight, or sixteen parallel workers with a single language model loaded once. The multithreading example demonstrates the configuration.

PDF-Native Workflows Without a Secondary Dependency

Organizations that receive documents primarily as PDFs — insurance claims, contracts, invoices, tax forms — face a compounded problem with Tesseract.Net.SDK: they must maintain a PDF rendering library alongside the OCR library. When PdfiumViewer or iText releases a security patch, both libraries need coordinated updates and regression testing. When the PDF library has a bug rendering a specific PDF version, the OCR pipeline produces garbage text with no obvious root cause. IronOCR's native PDF support collapses that two-library stack to one. A single package install replaces both. The PDF OCR use case page covers the complete workflow.

Enterprise Deployment Requirements

A Patagames license for Tesseract.Net.SDK comes with email and forum support from a single individual developer. There is no SLA, no guaranteed response time, and no escalation path. For applications in regulated industries — healthcare, finance, government — procurement teams increasingly require that software vendors provide documented SLAs, security disclosure processes, and organizational continuity guarantees. Patagames, as operated by an individual developer, cannot meet those requirements. IronOCR is developed by Iron Software, a commercial entity with dedicated support, security processes, and licensing terms compatible with enterprise procurement requirements. The licensing page documents available support tiers.

Namespace and Instance Pattern

The code change from Tesseract.Net.SDK to IronOCR is shallow. Replace using Patagames.Ocr; with using IronOcr;. Replace OcrApi.Create() with new IronTesseract(). Replace api.Init(Languages.English) with ocr.Language = OcrLanguage.English. The functional logic of the calling code does not change. A straightforward extraction service can be migrated in under an hour.

// Before: Tesseract.Net.SDK
using Patagames.Ocr;

using (var api = OcrApi.Create())
{
    api.Init(Languages.English);
    return api.GetTextFromImage(imagePath);
}

// After: IronOCR
using IronOcr;

var ocr = new IronTesseract();
using var input = new OcrInput();
input.LoadImage(imagePath);
return ocr.Read(input).Text;

// Before: Tesseract.Net.SDK
using Patagames.Ocr;

using (var api = OcrApi.Create())
{
    api.Init(Languages.English);
    return api.GetTextFromImage(imagePath);
}

// After: IronOCR
using IronOcr;

var ocr = new IronTesseract();
using var input = new OcrInput();
input.LoadImage(imagePath);
return ocr.Read(input).Text;

Imports Patagames.Ocr

Using api = OcrApi.Create()
    api.Init(Languages.English)
    Return api.GetTextFromImage(imagePath)
End Using

Imports IronOcr

Dim ocr As New IronTesseract()
Using input As New OcrInput()
    input.LoadImage(imagePath)
    Return ocr.Read(input).Text
End Using

The reading text from images tutorial and basic OCR example provide complete runnable samples with input validation and confidence checking.

Tessdata Folder Removal

After migration, the entire tessdata/ folder can be deleted from the project. IronOCR bundles language data with its NuGet packages. Remove all .traineddata references from the .csproj, remove the tessdata directory from deployment scripts, and remove any CI/CD pipeline steps that copy traineddata files. The IronOcr.Languages.* NuGet packages install language data as part of the normal package restore step — no separate download, no manual folder configuration, no build action settings in Visual Studio. The multiple languages guide covers language pack installation.

PDF Pipeline Simplification

Any code that installed PdfiumViewer, iText, or Ghostscript.NET for the purpose of rendering PDF pages before OCR can be removed entirely. Replace the entire multi-step render-to-temp-file-then-OCR pipeline with input.LoadPdf(pdfPath). Test specifically for password-protected PDFs, specific page ranges, and large documents exceeding 100 pages — these are the edge cases most likely to surface behavioral differences during validation.

Thread Model and Instance Lifetime

Tesseract.Net.SDK code typically creates one OcrApi instance per request or per thread to avoid thread-safety issues. IronOCR is thread-safe, so the IronTesseract instance should be created once (at application startup or as a singleton in a DI container) and reused across all requests. Creating a new IronTesseract() per request wastes the initialization overhead. Register it as a singleton in ASP.NET Core's service container and inject it where needed.