Tesseract is an open-source optical character recognition (OCR) engine originally developed by Hewlett-Packard and now maintained by Google and the community. It provides a C++ library (libtesseract) and a command-line tool (tesseract) that can recognize text from images in over 100 languages. The engine supports two recognition backends: a legacy engine based on character pattern matching with adaptive classifiers, and a modern LSTM-based neural network engine for line-level recognition. The architecture is modular, with separate components for page layout analysis (textord), character classification (classify), word recognition (wordrec), dictionary/DAG search (dict), and neural network layers (lstm). Training tools (src/training) allow users to build custom language models and fine-tune existing ones. The codebase is well-structured, extensively tested, and includes optimizations for SIMD (SSE, AVX, NEON, RVV). While primarily an application/library, it also has strong research elements in its LSTM training pipeline, feature extraction, and Unicode validation subsystems. The project has a long history but remains actively maintained, with recent commits addressing security, performance, and new architectures.
OCRmyPDF is a mature, production-grade command-line tool and Python library that adds searchable OCR text layers to scanned PDFs, producing PDF/A-compliant output by default. The system ingests PDFs or images, optionally deskews/cleans pages via unpaper, rasterizes with Ghostscript or pypdfium2, runs Tesseract OCR, grafts the recognized text into the original PDF using a plugin-based pipeline, and performs image optimization with pngquant/jbig2enc. It supports multiple output formats (PDF/A-1b, PDF/A-2b, plain PDF), a plugin system for replacing OCR engines, rasterizers, and progress bars, and includes a directory watcher for batch processing. Architecture is a modular Python CLI/library with external subprocess orchestration; core abstractions include typed OcrOptions (pydantic), Executor concurrency, FontProvider chains, and the OcrElement data model. The codebase is exceptionally well-tested with a comprehensive suite of unit, integration, and plugin-level tests, and demonstrates advanced patterns for PDF repair, cross-platform tool discovery, and atomic file operations.
Tesseract.js is a JavaScript library that brings the Tesseract OCR engine to the browser and Node.js by wrapping a WebAssembly port (tesseract.js-core). It enables optical character recognition (OCR) from images in over 100 languages, supporting multiple output formats (plain text, hOCR, TSV, PDF, JSON blocks, etc.) and pre-processing options like auto-rotation and rectangle cropping. The library's architecture is centered around two abstractions: Workers (each managing a Tesseract instance in a Web Worker or Worker Thread) and Schedulers (managing pools of Workers for parallel job execution). Key entry points are `createWorker` (which handles language loading, core initialization, and provides `recognize`, `detect`, `setParameters`, etc.) and `createScheduler` (which queues jobs among multiple Workers). Images can be provided as URLs, base64 strings, Buffers, File/Blob objects, or DOM elements (browser only). The core flow involves loading the appropriate WebAssembly binary based on SIMD support, downloading and caching language data (via IndexedDB or filesystem), initializing the Tesseract API, running recognition, and dumping results through a clean output abstraction. External dependencies include tesseract.js-core, wasm-feature-detect, idb-keyval, zlibjs, bmp-js, and node-fetch. The codebase is well-structured, modular, and has comprehensive tests (both Node and browser via Karma+Mocha), though some modules (like `createWorker`) mix concerns of worker lifecycle, job management, and message handling in a single file.
This repository contains 'officeParser', a robust Node.js and browser library for parsing 12 office document formats (DOCX, PPTX, XLSX, ODT, ODP, ODS, PDF, RTF, CSV, MD, HTML, EPUB) into a unified abstract syntax tree (AST) and generating high-fidelity output in 9 formats (JSON, text, Markdown, HTML, CSV, RTF, PDF, EPUB, and RAG-focused chunks). It provides a first-class CLI (`npx officeparser`) and a programmatic API (`parseOffice()` → AST → `.to(format, config?)`), with extensive configuration for OCR, chunking strategies, security limits, and format-specific dialects. The architecture follows a strict pipeline: format-specific parsers normalize documents into `OfficeParserAST`, then format-agnostic generators produce the desired output, enabling cross-format conversion and round-trip fidelity. The codebase demonstrates high craftsmanship with reusable utility modules (sanitization, typed error/warning systems, lazy ZIP handling, MathML-to-LaTeX conversion) and a comprehensive test suite covering parser baselines, generator baselines, security injection tests, and exhaustively tested edge cases. It supports browser and Node runtimes via dual CJS/ESM packages and bundled builds, including slim variants that minimize dependencies for browser environments. Key data flows include document metadata extraction, attachment handling (images, charts), OCR via Tesseract.js, PDF generation via Puppeteer, and semantic chunking for LLM ingestion. External dependencies include `pdfjs-dist`, `tesseract.js`, `fflate`, `chart.js`, and `puppeteer` (optional). While the repository is actively maintained with recent commits and CI across multiple Node versions, it shows some technical drift: deprecated API fields remain documented alongside replacements, and large files (e.g., OpenOfficeParser.ts at ~1600 lines) increase maintenance complexity. The builder has addressed past packaging issues (webpack context-module) and maintains sophisticated browser shims. Overall, it is a production-grade document conversion toolkit with exceptional reusability in its core utilities and a clean separation between parsing and generation.
HSR-Scanner is a desktop application that automates the extraction of game data from Honkai: Star Rail using computer vision techniques. It simulates keyboard and mouse inputs to navigate the game's inventory system, captures screenshots of items, and uses OCR (Optical Character Recognition) to extract item statistics. The extracted data is exported to JSON format compatible with third-party optimizers. The application features a PyQt6-based GUI with configurable scan options, hotkeys, and performance tuning parameters.
dpScreenOCR is a cross-platform desktop application for recognizing text from a selected screen region. It is built in C++ using the Tesseract OCR engine and Qt 5/6 for the graphical interface. The application runs as a system-tray utility: the user triggers a screen selection via a global hotkey, captures a portion of the screen, processes the image (grayscale conversion, upscaling, unsharp masking), and feeds it to Tesseract. Recognized text can be copied to the clipboard, added to a persistent history, or passed to an external executable. The architecture is modular, with separate libraries for OCR (dpso_ocr), system interaction (dpso_sys), image processing (dpso_img), network requests (dpso_net), sound playback (dpso_sound), configuration and history (dpso_ext), and a suite of cross-platform utilities (dpso_utils). Each module exposes a C API for C/C++ interoperability and includes platform-specific backends for X11 and Windows. The Qt UI provides a main window with recognition controls, a language manager for installing/updating Tesseract language packs, and export functionality for history. The project also packages a built-in gettext-compatible internationalization library (dp_intl) and supports 16 languages through Weblate. This is a pure application repository with no data analysis or machine learning training components. The code demonstrates solid engineering practices: clear separation of concerns, RAII resource management, comprehensive error handling, and an extensive CMake-based build system supporting multiple packaging formats (Unix bundle, Windows MSIX, Inno Setup). The test suite covers utility functions, geometry, SHA-256, version comparison, and platform-specific components, though the OCR pipeline itself has limited direct unit tests.
Text-Grab is a Windows desktop application for capturing and extracting text from screen regions, images, PDFs, and barcodes using on-device OCR (Windows OCR, Tesseract, Windows AI) and UI Automation. It provides multiple capture modes (fullscreen grab, grab frame, edit text window, quick lookup) and offers post-capture features like text editing, table analysis, unit conversion, expression evaluation, template-based extraction, text-to-speech, and clipboard integration. The application is privacy-focused as all processing runs locally. It is built as a monolithic WPF application using .NET 10 and WindowsAppSDK, with extensive unit and UI automation test coverage. The codebase is well-structured with reusable utility classes and custom controls, though some files (e.g., EditTextWindow) are very large and tightly coupled. The repository is actively maintained with recent commits, CI/CD pipelines, and dependabot integration.
WFInfo is a Windows desktop companion application for the game Warframe, built with WPF (.NET Framework 4.8). It uses OCR (Tesseract) to scan in-game reward screens, inventory items (SnapIt), and profile screens, then looks up real-time platinum and ducat prices from warframe.market. The architecture follows a service-oriented pattern with dependency injection (Microsoft.Extensions.DependencyInjection) for screenshot capture (GDI or Windows Graphics Capture), window information, HDR detection, and process finding. Key features include auto-detection of fissure rewards via Warframe's log file, a configurable overlay for price display, warframe.market listing management, language-specific text normalization (11+ locales), and a theme adjuster for OCR filtering. The application is Windows-only and tightly integrated with game UI, making it highly specialized but well-architected within its domain.
gImageReader is a mature, feature-rich desktop application that serves as a graphical frontend to the Tesseract OCR engine. It allows users to import images, PDFs, and DjVu documents, perform optical character recognition (OCR) with automatic or manual layout detection, and export the recognized text as plain text, hOCR (HTML-based OCR), PDF, or ODT. The application also integrates with scanner hardware via SANE (Linux) and TWAIN (Windows) backends, supports batch processing, and includes a spell checker, find/replace, and a substitution manager for post-processing. It is written in C++ and provides two parallel user interfaces: one using GTK+3 (gtkmm) and another using Qt5/Qt6, sharing a common core library in the `common/` directory. The architecture is a classic desktop monolith with a clear separation between the UI layer (GTK or Qt) and the backend logic (OCR, file handling, export). The codebase is well-organized with dedicated modules for scanning, image display, recognition, output editing, and export. Notable design patterns include a CRTP-based settings system (`ConfigSettings`), a custom tree model for file lists, and a worker-thread pattern for background scanning and rendering. The project has been actively maintained for over a decade, with recent commits and a large user base, though the dual-frontend approach introduces code duplication and maintenance overhead. While the application is not a research project, it demonstrates solid software engineering practices for a desktop GUI application. The most reusable components are the isolated utility classes in the `common/` directory, such as the CCITT Fax4 encoder, paper size definitions, and language mapping tables. These can be extracted and reused in other document-processing or PDF-generation projects with minimal modification. The overall code quality is good, with some areas showing age (e.g., version compatibility macros, WIP proofreading widget) but still functional and well-tested by the community.