FineReader Engine 12.8: Easier to Deploy, Easier to Scale, and More Ready for AI Workflows

ABBYY FineReader Engine 12.8 is about making strong OCR easier to use in the environments customers are building for now: containerized, scalable, and increasingly connected to AI-driven document workflows.

The core technology has already been there. FineReader Engine gives developers accurate recognition, strong layout analysis, CPU-based processing, and deep SDK (software development kit) control for applications that need reliable OCR inside their own products or workflows. With 12.8, the focus is on reducing friction around that technology so teams can get from implementation to production more cleanly.

This release moves FineReader Engine in that direction with official containerization materials, updated guidance, and DocLang support.

A more practical path to containers

For many teams, the hard part of optical character recognition (OCR) is not only recognition quality, rather it's getting the whole system deployed, configured, scaled, and maintained in an environment that matches how their business actually runs.

That is why containerization matters for FineReader Engine.

A containerized deployment gives teams a more predictable foundation for packaging dependencies, running consistently across environments, and scaling processing when document volume spikes. For document-heavy businesses, those spikes are normal. Month-end processing, claims batches, discovery work, migrations, backfile conversion, and customer uploads can all create short periods where the workload is much larger than the steady-state average.

In a traditional fixed environment, teams often have to choose between processing those spikes slowly or paying for enough always-on capacity to handle the worst day. Containers create a better operating model: scale up when the work arrives, process it quickly, and scale back down when the batch is done.

FineReader Engine is already fast per page. Containerization helps turn that speed into a more flexible deployment pattern.

In one internal test, we were able to process a 23,000-page workload across 60 containers in about 130 seconds.

That is the larger story behind this work.

It is not only "FineReader Engine can run in a container." It is that FineReader Engine can fit more naturally into modern, elastic document-processing architectures while keeping the ABBYY OCR quality and SDK control customers expect.

DocLang support

FineReader Engine 12.8 also includes DocLang support.

DocLang is a structured document output format built for the AI era. Instead of treating a document as only a block of text, DocLang preserves document structure in a way that is easier for downstream AI, automation, and document-processing systems to consume.

The short version: DocLang helps make document content more useful after OCR. A few reasons that matters:

• It gives AI systems cleaner, layout-aware input instead of a flat wall of extracted text.
• It can help reduce unnecessary token usage by preserving useful structure up front.
• It gives developers a more consistent output format for document ingestion, automation, and downstream analysis.
• It creates a better bridge between ABBYY's OCR strength and modern AI pipelines.

What that means is simple: FineReader Engine can handle the hard document preprocessing work, then provide output that is more natural for downstream systems to reason over.

What this means for developers

FineReader Engine 12.8 gives existing customers a better-supported starting point for containerized deployment, while also making FineReader Engine more relevant to teams building AI-oriented document pipelines.

For traditional OCR and document-processing applications, the value is straightforward: a cleaner deployment path around the same SDK foundation.

For AI workflows, the value is slightly different. FineReader Engine can act as a document preprocessing layer: take complex documents in, apply ABBYY OCR and layout understanding, and return structured output the rest of the pipeline can use.

For high-volume workloads, the container direction points toward scalable processing patterns using distributed workers, queues, cloud or private infrastructure, and capacity that expands when the work actually shows up.

Want to try ABBYY FineReader Engine for yourself?

If you want to see what this looks like in practice, the best place to start is the FineReader Engine 12.8 release notes. They summarize the release, including Docker container support and the new DocLang export format.

From there, consider:

• Reviewing the Linux Docker container instructions and choose the setup that matches your licensing approach.
• If you want to test DocLang output, review the DocLang export option and wire it into the export flow you are evaluating.

That should give you a good first pass at the 12.8 experience: run FineReader Engine in a container, process a real document, and start testing structured output for your own document pipeline.

FineReader Engine 12.8 makes Document AI more deployable, more scalable, and more useful in AI-driven document workflows. It keeps the SDK foundation intact while opening a cleaner path for customers who want modern deployment, structured output, and high-throughput document processing without giving up ABBYY's OCR quality.