KO | EN

GitLite

Minimalist Open Source Repository Search Engine

gitlite — search

#dsh #dsh-plugin #ai-agent #developer-tools #codex #typescript #cli #deepseek-harness #claude-code #ai-agents #mcp #rust

ppu-paddle-ocr

★ 122 Open GitHub ↗

Lightweight, probably the fastest PaddleOCR SDK in TypeScript. Multilingual Support. Runs anywhere JavaScript runs: Node.js, Bun, Deno, mobile react-native, web browsers, web worker, and browser extensions. Docker & CLI supported. The official SDK is browser-only.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# ppu-paddle-ocr

[![Slack](https://img.shields.io/badge/Slack-Community-4A154B?logo=slack&logoColor=white)](https://join.slack.com/t/ppupaddleocrcommunity/shared_invite/zt-3uzp1uuma-lrkEq8OYBYhGdUtzRoVmUg) [![NPM](https://img.shields.io/npm/dw/ppu-paddle-ocr)](https://www.npmjs.com/package/ppu-paddle-ocr) [![npm version](https://img.shields.io/npm/v/ppu-paddle-ocr)](https://www.npmjs.com/package/ppu-paddle-ocr) [![Provenance](https://img.shields.io/badge/npm-signed%20provenance-blue?logo=npm)](https://www.npmjs.com/package/ppu-paddle-ocr#provenance) [![License: MIT](https://img.shields.io/npm/l/ppu-paddle-ocr)](https://raw.githubusercontent.com/PT-Perkasa-Pilar-Utama/ppu-paddle-ocr/main/LICENSE) [![OpenSSF Scorecard](https://api.scorecard.dev/projects/github.com/PT-Perkasa-Pilar-Utama/ppu-paddle-ocr/badge)](https://scorecard.dev/viewer/?uri=github.com/PT-Perkasa-Pilar-Utama/ppu-paddle-ocr) [![Socket Badge](https://socket.dev/api/badge/npm/package/ppu-paddle-ocr)](https://socket.dev/npm/package/ppu-paddle-ocr) [![OpenSSF Best Practices](https://www.bestpractices.dev/projects/12963/badge)](https://www.bestpractices.dev/projects/12963)

Lightweight, probably the fastest PaddleOCR SDK in TypeScript. Multilingual Support. Runs anywhere JavaScript runs: Node.js, Bun, Deno, web browsers, web worker, browser extensions, and React Native (iOS/Android). Docker & CLI supported. The official SDK is browser-only and significantly slower. [Compare it for yourself](https://paddle-ocr-comparison.snowfluke.workers.dev/). Fine tune it? [fine-tuning on your data](#fine-tuning-on-your-data).

Need it as HTTP-service? dockerized? we've got you covered! Quickly spins up ppu-paddle-ocr REST API here: [ppu-paddle-ocr-serve](/apps/serve/README.md). Need a CLI instead? sure here: [ppu-paddle-ocr CLI support](#command-line). Adjust the config & model for your use case, [see config recommendation](#choosing-a-model-and-configuration). Are you AI Agents? you can learn quickly by using the skill in the `skill-ppu-paddle-ocr` folder.

![ppu-paddle-ocr demo](https://raw.githubusercontent.com/PT-Perkasa-Pilar-Utama/ppu-paddle-ocr/refs/heads/main/assets/ppu-paddle-ocr-demo.jpg)

```ts
import { PaddleOcrService } from "ppu-paddle-ocr";

const service = new PaddleOcrService();
await service.initialize();

const result = await service.recognize("./receipt.jpg");
console.log(result.text);

await service.destroy();
```

## Table of Contents

- [Quick Start](#quick-start)
- [Why ppu-paddle-ocr?](#why-ppu-paddle-ocr)
- [Runtime Support](#runtime-support)
- [Installation](#installation)
- [Core Usage](#core-usage)
  - [Basic Recognition](#basic-recognition)
  - [Custom Models](#custom-models)
  - [Changing Models at Runtime](#changing-models-at-runtime)
  - [Per-Call Options](#per-call-options)
  - [Detection Only](#detection-only)
- [Command Line](#command-line)
  - [Standalone Binaries](#standalone-binaries)
- [Batch Recognition](#batch-recognition)
- [Recognition Strategies](#recognition-strategies)
- [Choosing a Model and Configuration](#choosing-a-model-and-configuration)
- [Image Preprocessing](#image-preprocessing)
- [Processing Engine](#processing-engine)
- [Web / Browser Support](#web--browser-support)
  - [Using a Bundler](#using-a-bundler-vite-webpack-etc)
  - [Main-Thread Usage (No Worker)](#main-thread-usage-no-worker)
  - [CDN (No Bundler)](#cdn-no-bundler)
  - [WebGPU Acceleration](#webgpu-acceleration)
  - [Multithreaded WASM (Cross-Origin Isolation)](#multithreaded-wasm-cross-origin-isolation)
- [React Native (Mobile)](#react-native-mobile)
- [Models and Language Support](#models-and-language-support)
  - [PP-OCRv6 Models](#pp-ocrv6-models)
  - [Cache Location](#cache-location-node--bun)
  - [Multilingual Support](#multilingual-support)
  - [Switching Languages](#switching-languages)
  - [Server Models](#server-models-higher-accuracy)
  - [INT8 Quantization](#int8-quantization)
  - [Model Output Limitations](#model-output-limitations)
  - [Converting Custom Models](#converting-custom-paddlepaddle-models)
  - [Fine-Tuning on Your Data](#fine-tuning-on-your-data)
- [Configuration Reference](#configuration-reference)
  - [PaddleOptions](#paddleoptions)
  - [RecognizeOptions](#recognizeoptions)
  - [DetectOptions](#detectoptions)
  - [ModelPathOptions](#modelpathoptions)
  - [DetectionOptions](#detectionoptions)
  - [RecognitionOptions](#recognitionoptions)
  - [DebuggingOptions](#debuggingoptions)
  - [SessionOptions](#sessionoptions)
  - [ProcessingOptions](#processingoptions)
- [Benchmark](#benchmark)
- [Ecosystem](#ecosystem)
- [Contributing](#contributing)
- [License](#license)
- [Support](#support)
- [Scripts](#scripts)

## Why ppu-paddle-ocr?

- **Lightweight**, minimal dependencies, optimized for performance.
- **Pre-packed models**, PP-OCRv6 tiny models (~6 MB, multilingual) are fetched and cached automatically on first run; the full-dictionary small/medium tiers and language-specific variants are one option away. Supports additional variants via [ppu-paddle-ocr-models](https://github.com/PT-Perkasa-Pilar-Utama/ppu-paddle-ocr-models).
- **Runs everywhere**, Node.js, Bun, Deno, web browsers, web workers, browser extensions, and React Native (iOS/Android). The official SDK is browser-only.
- **Customizable**, custom models, dictionaries, and per-call overrides.
- **TypeScript**, full type definitions.

## Runtime Support

The same package, the same API, every JavaScript runtime:

| Runtime                   | How to install                                                                                              | Try it                                                                                           |
| ------------------------- | ----------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ |
| **Node.js**               | `npm install ppu-paddle-ocr onnxruntime-node`                                                               | [npm package](https://www.npmjs.com/package/ppu-paddle-ocr)                                      |
| **Bun**                   | `bun add ppu-paddle-ocr onnxruntime-node`                                                                   | [npm package](https://www.npmjs.com/package/ppu-paddle-ocr)                                      |
| **Deno**                  | `deno add jsr:@snowfluke/ppu-paddle-ocr`                                                                    | [JSR package](https://jsr.io/@snowfluke/ppu-paddle-ocr)                                          |
| **Web browser**           | `npm install ppu-paddle-ocr onnxruntime-web` (import `/web` subpath)                                        | [Live demo](https://ppu-paddle-ocr.snowfluke.workers.dev/)                                       |
| **Web worker**            | Same as web; the `/web` subpath runs in workers and MV3 service workers unchanged.                          | [Web Workers](#web-workers)                                                                      |
| **Browser extension**     | Same as web; bundle `ppu-paddle-ocr/web` with your extension's bundler.                                     | [Example extension repo](https://github.com/PT-Perkasa-Pilar-Utama/ppu-paddle-ocr-extension)     |
| **Mobile (React Native)** | `npm install ppu-paddle-ocr onnxruntime-react-native @shopify/react-native-skia` (import `/mobile` subpath) | [Example app](https://github.com/PT-Perkasa-Pilar-Utama/ppu-paddle-ocr-mobile-react-native-demo) |

## Installation

```bash
npm install ppu-paddle-ocr onnxruntime-node onnxruntime-web
```

Omit `onnxruntime-node` or `onnxruntime-web` depending on your target environment (Node/Bun vs browser).

### CLI (global install)

To use the [command line](#command-line) without `bunx`/`npx`, install globally, this puts a `ppu-paddle-ocr` command on your `PATH`:

```bash
npm install -g ppu-paddle-ocr onnxruntime-node      # or: bun add -g ppu-paddle-ocr onnxruntime-node
ppu-paddle-ocr recognize receipt.jpg
```

`onnxruntime-node` (~258MB of native binaries) is an optional peer dependency, install it alongside - the CLI needs it. Notes:

- **bun**: ensure `~/.bun/bin` is on your `PATH` (npm's global bin usually already is).
- **Updates are manual**, re-run the install with `@latest` to upgrade. (`bunx`/`npx` always fetch the latest but can serve a stale cache; a global install pins the version and you own upgrades.)
- It's still the Node/Bun build, a global install gives you a global command, not a standalone binary, so Node or Bun must be present. For a true standalone binary, see [Standalone Binaries](#standalone-binaries) below.

### Standalone Binaries

Every release attaches self-contained executables, no Node, Bun, or `npm install` required. Download, extract, run:

```bash
curl -L https://github.com/PT-Perkasa-Pilar-Utama/ppu-paddle-ocr/releases/latest/download/ppu-paddle-ocr-linux-x64.tar.gz | tar xz
./ppu-paddle-ocr-linux-x64 recognize receipt.jpg
```

Notes:

- **Size and first run.** ~50 MB download, ~140-200 MB extracted (the executable embeds the Bun runtime, ONNX Runtime, and the canvas engine; `tar` preserves the executable bit). Models (~6 MB) still download to `~/.cache/ppu-paddle-ocr` on first run, exactly like the npm CLI.
- **Slim variant.** Each target also ships a `-slim` archive (e.g. `ppu-paddle-ocr-linux-x64-slim.tar.gz`) that excludes the OpenCV engine: ~28 MB smaller extracted, though only ~5 MB smaller to download (the OpenCV payload compresses well). It always uses the `canvas-native` engine and rejects `--engine opencv`; accuracy on the reference receipt is near-identical (see [Benchmark](#benchmark)). Pick slim for disk and memory footprint; pick full if you want the opencv engine.
- **macOS Gatekeeper.** The binaries are ad-hoc signed but not Apple-notarized. If macOS blocks a downloaded binary, clear the quarantine flag: `xattr -d com.apple.quarantine ./ppu-paddle-ocr-darwin-arm64` (or right-click, Open, once).
- **Windows SmartScreen.** Unrecognized-app warning on first run: "More info", then "Run anyway".
- **Intel Macs and Alpine (musl) are not covered**, onnxruntime ships no darwin-x64 or musl builds; use `npx`/`bunx` there.
- **Verify a download** (checks run against the archive, before extraction; both are attached per release):

```bash
# Sigstore signature (bundle is attached next to each archive)
cosign verify-blob ppu-paddle-ocr-linux-x64.tar.gz \
  --bundle ppu-paddle-ocr-linux-x64.tar.gz.sigstore.json \
  --certificate-identity-regexp "github.com/PT-Perkasa-Pilar-Utama/ppu-paddle-ocr" \
  --certificate-oidc-issuer https://token.actions.githubusercontent.com

# GitHub build provenance (SLSA)
gh attestation verify ppu-paddle-ocr-linux-x64.tar.gz --repo PT-Perkasa-Pilar-Utama/ppu-paddle-ocr
```

## Core Usage

### Basic Recognition

```ts
import { PaddleOcrService } from "ppu-paddle-ocr";

const service = new PaddleOcrService({
  debugging: {
    debug: false,
    verbose: true,
  },
});

await service.initialize();

const result = await service.recognize("./assets/receipt.jpg");
console.log(result.text);

await service.destroy();
```

### Custom Models

**Using preset models**, import constants for quick switching:

```ts
import { PaddleOcrService, V6_SMALL_MODEL, V5_EN_MOBILE_MODEL } from "ppu-paddle-ocr";

// PP-OCRv6 small (full dictionary; the default is PP-OCRv6 tiny)
const service = new PaddleOcrService({ model: V6_SMALL_MODEL });

// Switch to PP-OCRv5 English
const service = new PaddleOcrService({ model: V5_EN_MOBILE_MODEL });
```

**Available presets:**

- **v6**: `V6_TINY_MODEL` (default), `V6_SMALL_MODEL`, `V6_MEDIUM_MODEL`
- **v5**: `V5_EN_MOBILE_MODEL`, `V5_EN_MOBILE_INT8_MODEL`, `V5_EN_SERVER_MODEL`, `V5_MOBILE_MODEL`, `V5_SERVER_MODEL`
- **v5 languages**: `V5_ARABIC_MOBILE_MODEL`, `V5_CYRILLIC_MOBILE_MODEL`, `V5_DEVANAGARI_MOBILE_MODEL`, `V5_GREEK_MOBILE_MODEL`, `V5_ESLAV_MOBILE_MODEL`, `V5_KOREAN_MOBILE_MODEL`, `V5_LATIN_MOBILE_MODEL`, `V5_TAMIL_MOBILE_MODEL`, `V5_TELUGU_MOBILE_MODEL`, `V5_THAI_MOBILE_MODEL`
- **v4**: `V4_EN_MOBILE_MODEL`, `V4_MOBILE_MODEL`, `V4_SERVER_MODEL`, `V4_SERVER_DOC_MODEL`
- **v3**: `V3_MOBILE_MODEL`, `V3_JAPANESE_MOBILE_MODEL`

**Granular override**, mix presets with custom paths:

```ts
const service = new PaddleOcrService({
  model: {
    ...V6_SMALL_MODEL,
    detection: "./models/custom-det.onnx", // Override just detection
  },
});
```

**Fully custom**, pass file paths, URLs, or `ArrayBuffer`s:

```ts
const service = new PaddleOcrService({
  model: {
    detection: "./models/custom-det.onnx",
    recognition: "https://example.com/models/custom-rec.onnx",
    charactersDictionary: customDictArrayBuffer,
  },
});

await service.initialize();
```

### Changing Models at Runtime

```ts
const service = new PaddleOcrService();
await service.initialize();

await service.changeDetectionModel("./models/new-det.onnx");
await service.changeRecognitionModel("./models/new-rec.onnx");
await service.changeTextDictionary("./models/new-dict.txt");
```

### Per-Call Options

Each `recognize()` call accepts `RecognizeOptions` for fine-grained control:

```ts
// Custom dictionary for one-off recognition
const result = await service.recognize("./assets/receipt.jpg", {
  dictionary: "./models/new-dict.txt",
});

// Disable caching for fresh processing
const fresh = await service.recognize("./assets/receipt.jpg", {
  noCache: true,
});

// Combine options
const result = await service.recognize("./assets/receipt.jpg", {
  noCache: true,
  flatten: true,
  strategy: "per-box",
});
```

### Detection Only

`detect()` runs only the detection model - no recognition - and returns the
bounding boxes of the text regions it finds. Useful when you only need layout
(where the text is), or want to feed the crops into your own pipeline.

```ts
// Just the boxes
const { boxes } = await service.detect(imageBuffer);
// boxes: { x, y, width, height }[] in original image coordinates

// Also return each region as a PNG buffer, index-aligned with boxes
const { crops } = await service.detect(imageBuffer, { crop: true });
await Bun.write("first-region.png", crops![0]!);

// Or write the crops straight to a folder as crop_000.png, crop_001.png, ...
await service.detect(imageBuffer, { saveCropsTo: "./out/regions" });

// DetectOptions extends DetectionOptions, so any tuning field
// can be overridden per call:
const { boxes: bigOnly } = await service.detect(imageBuffer, {
  minimumAreaThreshold: 500,
  maxSideLength: 960,
});
```

`detect()` accepts the same inputs as `recognize()` (`ArrayBuffer`, canvas,
absolute path, or URL) and works on all entry points. `saveCropsTo` is
Node/Bun only (ignored on web/mobile); `crop: true` is not supported on React
Native, where the Skia canvas cannot be encoded to PNG.

Also available as the CLI `detect` command and the serve app's
`POST /v1/detect` - see [Command Line](#command-line) and
[`apps/serve`](/apps/serve/README.md).

## Command Line

The package ships a `bin`, so you can OCR without writing any code. In a project that has `ppu-paddle-ocr` and `onnxruntime-node` installed, `bunx`/`npx` resolve the local install directly; for zero-install runs use `npx -p onnxruntime-node -p ppu-paddle-ocr ppu-paddle-ocr <args>` or a [global install](#cli-global-install):

```bash
# one image -> recognized text on stdout
bunx ppu-paddle-ocr recognize receipt.jpg

# a URL, as structured JSON
npx ppu-paddle-ocr recognize https://example.com/invoice.png --json --pretty

# detection only: bounding boxes as JSON, optionally saving each region as a PNG
bunx ppu-paddle-ocr detect receipt.jpg --save-crops ./regions --pretty

# zero-install (no local ppu-paddle-ocr): npx can pull both packages
npx -p onnxruntime-node -p ppu-paddle-ocr ppu-paddle-ocr recognize receipt.jpg

# many images (glob), fastest strategy, written to a file
bunx ppu-paddle-ocr batch "scans/*.png" --strategy cross-line --json -o results.json

# print each result as it finishes
bunx ppu-paddle-ocr stream "scans/*.png"

# pick a catalogue preset by name (granular --model-* flags override parts)
bunx ppu-paddle-ocr recognize receipt.jpg --model v6-tiny
bunx ppu-paddle-ocr recognize receipt.jpg --model v5-thai-mobile

# pre-warm / clear the model cache, inspect the active config (+ preset list)
bunx ppu-paddle-ocr download-models
bunx ppu-paddle-ocr clear-cache
bunx ppu-paddle-ocr models --json
```

Every `PaddleOptions` / `RecognizeOptions` field maps to a flag:

| Flags                                                                                                                                                                                | Applies to         | Purpose                                                                               |
| :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :----------------- | :------------------------------------------------------------------------------------ |
| `--model <preset>`                                                                                                                                                                   | all commands       | Catalogue preset (`v6-tiny`, `v6-small`, `v5-en-mobile`, ...); list: `models --json`  |
| `--model-detection`, `--model-recognition`, `--model-dict`                                                                                                                           | all commands       | Raw paths/URLs; each overrides that part of the preset                                |
| `--strategy`, `--flatten`, `--no-cache`, `--image-height`, `--min-confidence`, `--max-crop-source-side-length`, `--main-thread-yield-ms`                                             | recognition        | Recognition behavior (strategy, flat output, confidence filter, crop-source cap, ...) |
| `--engine`, `--execution-providers`                                                                                                                                                  | all commands       | `opencv` \| `canvas-native`; ONNX providers (e.g. `cuda,cpu`)                         |
| `--max-side-length`, `--padding-vertical`, `--padding-horizontal`, `--min-area`, `--mean`, `--std`                                                                                   | all incl. `detect` | Detection tuning (`--max-side-length` accepts `auto`)                                 |
| `--save-crops <dir>`                                                                                                                                                                 | `detect` only      | Write one PNG per detected box                                                        |
| `--concurrency`                                                                                                                                                                      | `batch`, `stream`  | Images processed in parallel                                                          |
| `--json`, `--pretty`, `-o`/`--output`, `-q`/`--quiet`, `--verbose`                                                                                                                   | all commands       | Output format and destination                                                         |
| =======                                                                                                                                                                              |
| Flags                                                                                                                                                                                | Applies to         | Purpose                                                                               |
| :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :----------------- | :------------------------------------------------------------------------------------ |
| `--model <preset>`                                                                                                                                                                   | all commands       | Catalogue preset (`v6-tiny`, `v6-small`, `v5-en-mobile`, ...); list: `models --json`  |
| `--model-detection`, `--model-recognition`, `--model-dict`                                                                                                                           | all commands       | Raw paths/URLs; each overrides that part of the preset                                |
| `--strategy`, `--flatten`, `--no-cache`, `--image-height`, `--min-confidence`, `--max-crop-source-side-length`, `--rec-batch-size`, `--no-rotate-vertical-crops`, `--space-recovery` | recognition        | Recognition behavior (strategy, flat output, confidence filter, crop-source cap, ...) |
| `--engine`, `--execution-providers`                                                                                                                                                  | all commands       | `opencv` \| `canvas-native`; ONNX providers (e.g. `cuda,cpu`)                         |
| `--max-side-length`, `--padding-vertical`, `--padding-horizontal`, `--min-area`, `--mean`, `--std`                                                                                   | all incl. `detect` | Detection tuning (`--max-side-length` accepts `auto`)                                 |
| `--save-crops <dir>`                                                                                                                                                                 | `detect` only      | Write one PNG per detected box                                                        |
| `--concurrency`                                                                                                                                                                      | `batch`, `stream`  | Images processed in parallel                                                          |
| `--json`, `--pretty`, `-o`/`--output`, `-q`/`--quiet`, `--verbose`                                                                                                                   | all commands       | Output format and destination                                                         |

Recognized text goes to **stdout**; progress and logs go to **stderr**, so output pipes cleanly. Exit codes: `0` success, `1` runtime error, `2` usage error.

Run `bunx ppu-paddle-ocr help` for the full reference. The CLI uses the default v6 tiny models unless you select a `--model` preset or override the `--model-*` flags.

## Batch Recognition

`batchRecognize()` runs `recognize()` over many images with **bounded concurrency**, so memory stays in check: at most `concurrency` images are decoded and in flight at once. Results are returned **index-aligned** to the inputs regardless of completion order.

```ts
const results = await service.batchRecognize([buf1, buf2, buf3]);
results.forEach((r, i) => console.log(i, r.text));
```

Concurrency defaults to `"auto"`, `1` when an accelerator provider (CUDA, WebGPU) is configured (a shared session serializes device work anyway, and parallel runs would stack VRAM), and a small CPU default otherwise to overlap JS preprocessing with native inference. Override it explicitly when you know your hardware:

```ts
await service.batchRecognize(images, { concurrency: 8, flatten: true });
```

Use `settle: true` to keep going when an image fails, each slot becomes `{ status, value | reason }` instead of the call rejecting:

```ts
const results = await service.batchRecognize(images, { settle: true });
for (const r of results) {
  if (r.status === "fulfilled") console.log(r.value.text);
  else console.error("failed:", r.reason);
}
```

Track progress and cancel with the usual primitives:

```ts
const ac = new AbortController();
await service.batchRecognize(images, {
  signal: ac.signal,
  onProgress: (done, total) => console.log(`${done}/${total}`),
});
```

To consume results as they finish (and avoid buffering the whole batch), stream them, each item carries its input `index` for reordering:

```ts
for await (const item of service.batchRecognizeStream(images)) {
  if (item.status === "fulfilled") console.log(item.index, item.value.text);
}
```

`batchRecognize` / `batchRecognizeStream` also accept any `Iterable` or `AsyncIterable` of inputs, so a directory walk or queue never has to be materialized in memory at once. All `RecognizeOptions` (`flatten`, `strategy`, `dictionary`, `noCache`) are accepted and applied to every image. See [`BatchRecognizeOptions`](#batchrecognizeoptions) for the full surface.

## Recognition Strategies

Recognition strategies control how detected text regions are cropped from the canvas and fed into the recognition model. Fewer inference calls means faster throughput.

See [Choosing a model and configuration](#choosing-a-model-and-configuration) for a workload-based selection matrix.

Strategies are set in `RecognitionOptions`:

```ts
const service = new PaddleOcrService({
  recognition: { strategy: "cross-line" },
});
await service.initialize();
```

![recognition strategies](https://raw.githubusercontent.com/PT-Perkasa-Pilar-Utama/ppu-paddle-ocr/refs/heads/main/assets/recognition-strategies.jpg)

## Choosing a Model and Configuration

The defaults (PP-OCRv6 tiny, `per-line`, `maxSideLength: "auto"`, `minimumAreaThreshold: 20`, `minimumConfidence: 0.5`, `opencv` engine) are tuned to be fast and accurate across the tested corpus, including the receipt photo.

For dense document pages or full multilingual coverage, step up to `V6_SMALL_MODEL`. Each recipe below was validated against the committed example image it names.

### Model families

v5 models are single-language specialists; v6 models are multilingual (one model, 50+ languages). If your documents are always one known language, the matching v5 model avoids cross-language confusion; if the language varies or mixes, stay on v6.

Parameter counts, file names, and preset-switching code live in
[PP-OCRv6 Models](#pp-ocrv6-models).

### Input characteristics

| Input looks like                  | What to set                                                   | Why                                                                                                              |
| :-------------------------------- | :------------------------------------------------------------ | :--------------------------------------------------------------------------------------------------------------- |
| Dark theme (light text on dark)   | nothing, keep defaults                                        | models read inverted text natively; pre-inverting hurt accuracy in our tests                                     |
| Light theme, clean digital render | defaults                                                      | high-contrast digital text is the easy case                                                                      |
| Dense lines (documents, tables)   | `V6_SMALL_MODEL`; `cross-line` for max throughput             | full dictionary and a more sensitive detector for small body text                                                |
| Sparse short labels (UI, forms)   | defaults                                                      | merged line context fixes short-label misreads that isolated crops produce                                       |
| Tiny text / fine print            | `"auto"` (default) scales the cap with input size             | text below ~10px after downscale stops being detected; override with a fixed `maxSideLength` only if it persists |
| Landscape / wide pages            | defaults; the cap applies to the longest side                 | `"auto"` keeps mid-size pages near native scale instead of downscaling sooner                                    |
| Low contrast                      | `V6_MEDIUM_MODEL` if defaults fall short                      | weak probability responses need more pixels or a stronger model                                                  |
| Photo (camera, uneven lighting)   | defaults (99.5% on the receipt); medium for the hardest shots | decode refinements beat small (97.4%) here; `"auto"` sizing keeps large photos near native scale                 |
| Tilted / rotated                  | deskew first with `ppu-ocv` `DeskewService`                   | every model tier degrades sharply past a few degrees of skew                                                     |
| One known language                | the matching v5 model                                         | single-language dictionary, no cross-language confusion                                                          |

## Image Preprocessing

PaddleOCR works best with grayscale or thresholded images. Use [ppu-ocv](https://github.com/PT-Perkasa-Pilar-Utama/ppu-ocv) for preprocessing before recognition:

```ts
import { ImageProcessor, CanvasProcessor } from "ppu-ocv";
const processor = new ImageProcessor(bodyCanvas);

// For non-OpenCV environments (e.g. browser extensions)
// const processor = new CanvasProcessor(bodyCanvas)

processor.grayscale().blur();
const canvas = processor.toCanvas();
processor.destroy();
```

### Document Correction (Rotated or Warped Pages)

ppu-paddle-ocr deliberately ships no orientation-classifier models - most inputs don't need them, and skipping them keeps the default path fast. For scans that arrive rotated (90/180/270), curved, or photographed at an angle, compose with [ppu-doc-correction](https://github.com/PT-Perkasa-Pilar-Utama/ppu-doc-correction), which provides exactly those models as independent, lazy-loading services:

```ts
import { DocOrientService } from "ppu-doc-correction";

const orient = new DocOrientService();
const { orientation, correctedImage } = await orient.run(imageBuffer);
// feed correctedImage to service.recognize() - upside-down scans now read correctly
```

`TextUnwarpService` (UVDoc) flattens curved or warped pages the same way, and `DeskewService` from [ppu-ocv](https://github.com/PT-Perkasa-Pilar-Utama/ppu-ocv) handles small-angle tilt. Individual vertical text lines need none of this: `recognition.rotateVerticalCrops` (on by default) rotates tall crops before recognition at zero model cost.

## Processing Engine

Two image processing backends are available for detection preprocessing and recognition resizing:

| Engine            | Default | OpenCV Required | Notes                                               |
| :---------------- | :-----: | :-------------: | :-------------------------------------------------- |
| `"opencv"`        |   Yes   |       Yes       | Uses OpenCV.js from `ppu-ocv`. More accurate boxes. |
| `"canvas-native"` |   No    |       No        | Pure canvas from `ppu-ocv/canvas`. Lighter weight.  |

The browser build (`ppu-paddle-ocr/web`) always uses `canvas-native`, OpenCV.js is not bundled in the web entry point.

```ts
// OpenCV (default, recommended)
const service = new PaddleOcrService();

// Canvas-native (no OpenCV dependency)
const service = new PaddleOcrService({
  processing: { engine: "canvas-native" },
});
```

## Web / Browser Support

Import from `ppu-paddle-ocr/web` for browser-native capabilities (`HTMLCanvasElement`, `OffscreenCanvas`, `fetch` buffering).

### Using a Bundler (Vite, Webpack, etc.)

```ts
import { PaddleOcrService } from "ppu-paddle-ocr/web";

const service = new PaddleOcrService();
await service.initialize();

const file = document.getElementById("upload").files[0];

const img = new Image();
img.src = URL.createObjectURL(file);
await new Promise((r) => (img.onload = r));

const canvas = document.createElement("canvas");
canvas.width = img.width;
canvas.height = img.height;
canvas.getContext("2d").drawImage(img, 0, 0);

const result = await service.recognize(canvas);
console.log(result.text);
```

### Web Workers

The web build runs unchanged inside a Web Worker, a shared worker, or a Manifest V3 extension service worker. Every intermediate canvas comes from `OffscreenCanvas`, so the pipeline never touches `document` or `HTMLCanvasElement` and needs no shims.

Keep the service inside the worker and send image bytes across the boundary, so inference never blocks the main thread:

```ts
// worker.ts
import { PaddleOcrService } from "ppu-paddle-ocr/web";

const service = new PaddleOcrService();
const ready = service.initialize();

self.onmessage = async (event: MessageEvent<ArrayBuffer>) => {
  await ready;
  const result = await service.recognize(event.data);
  self.postMessage(result);
};
```

```ts
// main.ts
const worker = new Worker(new URL("./worker.ts", import.meta.url), { type: "module" });
worker.onmessage = (event) => console.log(event.data.text);

const bytes = await file.arrayBuffer();
worker.postMessage(bytes, [bytes]); // transferred, not copied
```

`recognize()` also accepts an `OffscreenCanvas` directly, which is what `canvas.transferControlToOffscreen()` hands the worker.

Notes:

- WebGPU detection behaves the same way in a worker and falls back to WASM when `navigator.gpu` is absent.
- Cross-origin isolation still governs WASM threading, see [Multithreaded WASM](#multithreaded-wasm-cross-origin-isolation). It is a property of the page, not of the worker.
- `isWebWorker()` is exported if you need to branch on the scope yourself.

```ts
import { isWebWorker } from "ppu-paddle-ocr/web";
```

### Main-Thread Usage (No Worker)

A worker is still the right home for OCR, but if you run `recognize()` directly
on the page (a plain `<script>` setup, no bundler, no worker), WASM inference
blocks the main thread and the tab freezes until the whole image is done.

To keep the page responsive, the web entry pauses ~10 ms before each
recognition inference on the main thread. The page paints and handles input
between inferences instead of locking up for the full run. The trade-off is a
slightly longer total time (roughly 10 ms per detected line).

Tune or disable it via `recognition.mainThreadYieldMs`:

```ts
// Longer pauses, smoother page (heavier UI around the OCR call)
const service = new PaddleOcrService({ recognition: { mainThreadYieldMs: 32 } });

// Disable: fastest total time, page frozen while recognizing
const service = new PaddleOcrService({ recognition: { mainThreadYieldMs: 0 } });
```

Inside a Web Worker this default is off (`0`), there is no UI to yield to.
Detection's single inference still blocks briefly either way; only the
per-line recognition loop yields.

### CDN (No Bundler)

See the [live demo](https://ppu-paddle-ocr.snowfluke.workers.dev/) for a complete ESM/CDN setup.

### WebGPU Acceleration

On WebGPU-capable browsers (Chrome/Edge on Windows/Linux/macOS, Firefox Nightly), ONNX inference automatically runs on the GPU, typically **2-5x faster** with no code changes. The library silently falls back to WASM if WebGPU is unavailable or fails.

Detection runs once during `initialize()` and is fully transparent.

```ts
import { isWebGpuAvailable, getDefaultWebExecutionProviders } from "ppu-paddle-ocr/web";

if (await isWebGpuAvailable()) {
  console.log("WebGPU supported");
}
```

#### Override Provider Preference

```ts
// Force WASM-only
const service = new PaddleOcrService({
  session: {
    executionProviders: ["wasm"],
    graphOptimizationLevel: "all",
  },
});
```

> The WASM binaries are still required even when WebGPU is the primary provider (used for graph optimization and fallback ops). When `ort.env.wasm.wasmPaths` is unset, pages and workers fall back to the jsDelivr copy of the exact `onnxruntime-web` version you loaded, so the binaries and the loader never disagree. Set it yourself before `initialize()` to self-host.

### Multithreaded WASM (Cross-Origin Isolation)

When the WASM backend is used (no WebGPU, or `executionProviders: ["wasm"]`), ONNX Runtime only runs multithreaded if the page is [cross-origin isolated](https://developer.mozilla.org/en-US/docs/Web/API/Window/crossOriginIsolated), otherwise `numThreads` is pinned to 1. Cross-origin isolation requires the `Cross-Origin-Opener-Policy: same-origin` and `Cross-Origin-Embedder-Policy: require-corp` response headers.

**If you can set those headers server-side, do that**, it's the correct fix and needs nothing from this package. WebGPU does not need isolation at all, so this only matters on the WASM fallback path.

For static hosts that can't set headers (e.g. GitHub Pages), the package ships an opt-in [coi-serviceworker](https://github.com/gzuidhof/coi-serviceworker) that injects the headers client-side. Copy it to your served root and load it from your page **before** anything else:

```html
<script src="/coi-serviceworker.js"></script>
```

Resolve the shipped copy from the package, e.g. in a build step:

```ts
// path on disk: node_modules/ppu-paddle-ocr/coi-serviceworker.js
const swPath = import.meta.resolve("ppu-paddle-ocr/coi-serviceworker.js");
```

> The service worker reloads the page once on first visit to apply the headers and rewrites all fetch responses. Don't use it if you already control your headers or run another service worker that conflicts.

## React Native (Mobile)

Run the same OCR pipeline on iOS and Android via the `ppu-paddle-ocr/mobile` entry. It uses `onnxruntime-react-native` (native JSI inference) and `ppu-ocv/canvas-mobile` (Skia-backed canvas) instead of their web counterparts.

```bash
npm install ppu-paddle-ocr onnxruntime-react-native @shopify/react-native-skia
```

```ts
import { PaddleOcrService } from "ppu-paddle-ocr/mobile";

const service = new PaddleOcrService();
await service.initialize();

// `imageBuffer` is an ArrayBuffer e.g. from a captured frame or a bundled asset.
const result = await service.recognize(imageBuffer, { flatten: true });
console.log(result.text);

await service.destroy();
```

Notes:

- **npm only, not JSR.** The mobile entry is published to npm but excluded from the JSR package: `onnxruntime-react-native` and `@shopify/react-native-skia` are native React Native modules that only resolve through npm/Metro, and JSR's Deno-based publish cannot resolve them (React Native itself cannot consume JSR packages). Install via npm/yarn/bun as shown above.
- **Native modules required.** Both `onnxruntime-react-native` and `@shopify/react-native-skia` ship native code, so you need a dev client or `expo prebuild`, **Expo Go is not supported**. Targets RN >= 0.74 / Expo SDK >= 51 (Hermes).
- **CPU inference.** Mobile runs on CPU by default; pass `session: { executionProviders: ["nnapi"] }` (Android) or `["coreml"]` (iOS) to opt into hardware acceleration. There is no WebGPU on React Native.
- **Camera capture is out of scope.** Pass a decoded frame from `react-native-vision-camera` or `expo-camera` as an `ArrayBuffer`.
- A runnable Expo example lives in a separate repo: [ppu-paddle-ocr-mobile-react-native-demo](https://github.com/PT-Perkasa-Pilar-Utama/ppu-paddle-ocr-mobile-react-native-demo).

## Models and Language Support

### PP-OCRv6 Models

PP-OCRv6 ships a **single unified model family** covering 50+ languages
(Simplified/Traditional Chinese, English, Japanese, 46+ Latin-script
languages, Arabic, Indic, ...), no per-language model files needed. The
package default is the **tiny** tier; which tier fits which workload is
covered in [Choosing a Model and Configuration](#choosing-a-model-and-configuration).

The default resolves to these files, downloaded and cached on first run:

Portable `.onnx` variants are available at [ppu-paddle-ocr-models](https://github.com/PT-Perkasa-Pilar-Utama/ppu-paddle-ocr-models), point `model.detection` / `model.recognition` at the `.onnx` URLs.

**Quick switching with presets:**

```ts
import {
  PaddleOcrService,
  V6_SMALL_MODEL,
  V6_MEDIUM_MODEL,
  V6_TINY_MODEL,
  V5_EN_MOBILE_MODEL,
} from "ppu-paddle-ocr";

// Default (v6 tiny) - same as passing no model option
const service = new PaddleOcrService({ model: V6_TINY_MODEL });

// Full dictionary
const serviceFull = new PaddleOcrService({ model: V6_SMALL_MODEL });

// Server-grade
const serviceServer = new PaddleOcrService({ model: V6_MEDIUM_MODEL });

// Pre-6.0.0 default (PP-OCRv5 English mobile)
const v5 = new PaddleOcrService({ model: V5_EN_MOBILE_MODEL });
```

### Cache Location (Node / Bun)

Models are cached under `~/.cache/ppu-paddle-ocr`:

```ts
// Warm the cache (e.g. in CI or Docker builds)
PaddleOcrService.downloadModels();

// Clear the cache
service.clearModelCache();
```

> In the browser, model files are fetched via `fetch()` on every page load and rely on the browser's HTTP cache. For persistent offline caching, use a Service Worker or store the `ArrayBuffer` in IndexedDB.

### Multilingual Support

PP-OCRv5 supports 40+ languages across different script systems. Pre-converted ONNX models are available at [ppu-paddle-ocr-models](https://github.com/PT-Perkasa-Pilar-Utama/ppu-paddle-ocr-models):

- **Latin**: English, French, German, Italian, Spanish, Portuguese, and 40+ others
- **Cyrillic**: Russian, Ukrainian, Bulgarian, Kazakh, Serbian, and 30+ related
- **Arabic**: Arabic, Persian, Urdu, Kurdish
- **Indic**: Hindi (Devanagari), Tamil, Telugu
- **East Asian**: Korean, Japanese
- **Southeast Asian**: Thai

### Switching Languages

**Using presets** (easiest):

```ts
import { PaddleOcrService, V5_THAI_MOBILE_MODEL, V5_ARABIC_MOBILE_MODEL } from "ppu-paddle-ocr";

// Thai
const service = new PaddleOcrService({ model: V5_THAI_MOBILE_MODEL });

// Arabic
const service = new PaddleOcrService({ model: V5_ARABIC_MOBILE_MODEL });
```

**Manual URLs** (advanced):

```ts
const MODEL_BASE =
  "https://media.githubusercontent.com/media/PT-Perkasa-Pilar-Utama/ppu-paddle-ocr-models/refs/heads/main";
const DICT_BASE =
  "https://raw.githubusercontent.com/PT-Perkasa-Pilar-Utama/ppu-paddle-ocr-models/refs/heads/main";

// Thai
const service = new PaddleOcrService({
  model: {
    detection: `${MODEL_BASE}/detection/PP-OCRv5_mobile_det_infer.onnx`,
    recognition: `${MODEL_BASE}/recognition/multi/th/v5/th_PP-OCRv5_mobile_rec_infer.onnx`,
    charactersDictionary: `${DICT_BASE}/recognition/multi/th/v5/ppocrv5_th_dict.txt`,
  },
});
```

### Server Models (Higher Accuracy)

**Using presets:**

```ts
import { PaddleOcrService, V5_EN_SERVER_MODEL, V5_SERVER_MODEL } from "ppu-paddle-ocr";

// PP-OCRv5 English server
const service = new PaddleOcrService({ model: V5_EN_SERVER_MODEL });

// PP-OCRv5 server (multilingual)
const service = new PaddleOcrService({ model: V5_SERVER_MODEL });
```

**Manual configuration:**

```ts
const service = new PaddleOcrService({
  model: {
    detection: `${MODEL_BASE}/detection/PP-OCRv5_server_det_infer.onnx`,
    recognition: `${MODEL_BASE}/recognition/PP-OCRv5_server_rec_infer.onnx`,
    charactersDictionary: `${DICT_BASE}/recognition/ppocrv5_dict.txt`,
  },
});
```

### INT8 Quantization

The recognition model's transformer MatMul operations can be dynamically quantized to INT8 with **no accuracy loss** (measured 99.22% -> 99.22%) and a 20-50% speedup on **x86-64 CPUs with VNNI** and **WebAssembly**.

> On Apple Silicon (M-series), INT8 is **not faster**, the FP32 NEON/Accelerate kernels outperform the INT8 MLAS path. Stick with FP32 on macOS ARM64.

**Using the preset:**

```ts
import { PaddleOcrService, V5_EN_MOBILE_INT8_MODEL } from "ppu-paddle-ocr";

const service = new PaddleOcrService({ model: V5_EN_MOBILE_INT8_MODEL });
```

**Custom quantization**, run the quantization helper:

```bash
pip install onnxruntime onnx sympy
python examples/quantize-onnx.py /path/to/en_PP-OCRv5_mobile_rec_infer.onnx
# -> produces en_PP-OCRv5_mobile_rec_infer_int8.onnx
```

Use the quantized model via `model.recognition`:

```ts
const service = new PaddleOcrService({
  model: {
    recognition: "https://example.com/en_PP-OCRv5_mobile_rec_infer_int8.onnx",
  },
});
```

INT8 `.ort` variants are also available in the [ppu-paddle-ocr-models](https://github.com/PT-Perkasa-Pilar-Utama/ppu-paddle-ocr-models) repo.

### Model Output Limitations

- **Tables**: Text within table cells is detected, but table structure is not preserved.
- **Math formulas**: Not optimized for mathematical notation.
- **Document layout**: For layout detection, see PP-DocLayoutV2/V3 models in [ppu-paddle-ocr-models](https://github.com/PT-Perkasa-Pilar-Utama/ppu-paddle-ocr-models).

### Converting Custom PaddlePaddle Models

See the [ONNX conversion guide](./examples/convert-onnx.ipynb).

### Fine-Tuning on Your Data

When stock accuracy on your documents is limited by domain quirks (dropped inter-word spaces, unusual fonts, ID-card hatching) rather than image quality, fine-tune the recognition model on your own labeled word crops. The [fine-tuning starter kit](./examples/fine-tune/README.md) has per-tier training configs (the tiny/small/medium YAMLs differ in neck, head, and dictionary, they are not interchangeable), a dataset preparation script that builds train/val/test splits from images with line-level ground truth, and the full train -> export -> ONNX -> `model.recognition` walkthrough.

## Configuration Reference

### `PaddleOptions`

```ts
import type { PaddleOptions } from "ppu-paddle-ocr";

export type PaddleOptions = {
  model?: ModelPathOptions;
  detection?: DetectionOptions;
  recognition?: RecognitionOptions;
  debugging?: DebuggingOptions;
  session?: SessionOptions;
  processing?: ProcessingOptions;
};
```

### `RecognizeOptions`

Per-call options for `recognize()`.

### `DetectOptions`

Per-call options for `detect()`. Extends [`DetectionOptions`](#detectionoptions),
so every detection tuning field (`maxSideLength`, `minimumAreaThreshold`,
`paddingVertical`, `paddingHorizontal`, `mean`, `stdDeviation`) can also be
overridden for a single call, plus:

### `BatchRecognizeOptions`

Extends `RecognizeOptions` (applied to every image) for `batchRecognize()` / `batchRecognizeStream()`.

| Property      |           Type           | Default  | Description                                                                              |
| :------------ | :----------------------: | :------: | :--------------------------------------------------------------------------------------- |
| `concurrency` |    `number \| "auto"`    | `"auto"` | Max images in flight. `"auto"` = `1` on an accelerator provider, small default on CPU.   |
| `settle`      |        `boolean`         | `false`  | When `true`, a failed image yields `{ status: "rejected", reason }` instead of throwing. |
| `signal`      |      `AbortSignal`       |  `null`  | Cancels the batch; pending images are not scheduled and the call rejects.                |
| `onProgress`  | `(done, total?) => void` |  `null`  | Called after each image settles, with the running count and total (if known).            |

### `ModelPathOptions`

> Leave a trailing newline in your dictionary file.

### `DetectionOptions`

Controls preprocessing and filtering during text detection.

### `RecognitionOptions`

Controls recognition preprocessing and strategy.

### `DebuggingOptions`

### `SessionOptions`

Any valid ONNX Runtime `InferenceSession.SessionOptions` property is accepted. ppu-paddle-ocr sets these defaults:

```ts
const service = new PaddleOcrService({
  session: {
    executionProviders: ["cpu"],
    graphOptimizationLevel: "all",
    enableCpuMemArena: true,
    enableMemPattern: true,
    executionMode: "sequential",
  },
});
```

### `ProcessingOptions`

## Benchmark

Benches use a small zero-dependency harness (`bench/harness.ts`): in-process timing, round-robin scheduling across rounds so thermal/GC drift hits every task equally, reporting the median plus min/max/stddev. Run `bun task bench`.

Representative results on Apple M1 / Bun 1.3.14 (20 rounds, opencv + canvas-native) at the shipped defaults (PP-OCRv6 tiny, `"auto"` sizing, `minimumConfidence: 0.5`, decode refinements):

```bash
task                                   median      +/-stddev        min        max
--------------------------------------------------------------------------------
[per-box][opencv][noCache]             139.7 ms      18.3 ms   135.3 ms   194.3 ms
[per-line][opencv][noCache]            138.8 ms      10.9 ms   132.9 ms   171.3 ms
[cross-line][opencv][noCache]          139.8 ms       8.0 ms   135.5 ms   168.6 ms
[per-box][canvas-native][noCache]      160.2 ms       7.9 ms   156.6 ms   192.4 ms
[per-line][canvas-native][noCache]     154.6 ms      10.3 ms   150.2 ms   188.0 ms
[cross-line][canvas-native][noCache]   161.9 ms      13.1 ms   156.2 ms   211.4 ms

=== Accuracy on receipt.jpg (ground truth: 383 chars) ===
  [opencv]        per-box=99.48%  per-line=99.48%  cross-line=94.26%
  [canvas-native] per-box=99.48%  per-line=99.22%  cross-line=94.78%
```

### Batch vs. concurrent `recognize()`

`bench/batch.bench.ts` compares the ways to OCR many images, tracking peak RSS alongside time. Captured on the previous v5 default (the relative comparison between sequential / `Promise.all` / `batchRecognize` is model-independent), median over 7 rounds of 16 images each, Apple M1 / Bun 1.3.14, opencv, `noCache`:

```bash
task                          median      +/-stddev        min        max   peak RSS
----------------------------------------------------------------------------------
sequential for-loop          3802.5 ms     300.6 ms  3169.4 ms  3979.7 ms    1059 MB
Promise.all(map(recognize))  3543.5 ms     254.0 ms  3030.0 ms  3768.0 ms    1428 MB
batchRecognize (auto)        3676.1 ms     200.9 ms  3217.1 ms  3761.3 ms    1096 MB
batchRecognize (c=4)         3653.8 ms     239.1 ms  3170.1 ms  3804.1 ms    1027 MB
batchRecognize (c=8)         3605.7 ms     187.6 ms  3202.1 ms  3786.6 ms    1096 MB
```

On CPU, throughput is bound by ONNX Runtime's native thread pool (which already saturates all cores per inference), so every parallel approach lands within ~4% on time, JS-level concurrency cannot add cores that are already busy.

The real difference is **memory**: unbounded `Promise.all` peaks at ~1430 MB and grows with batch size, while `batchRecognize` stays **bounded at ~1030-1100 MB regardless of `N`**.

So `batchRecognize` matches the fastest approach at lower, bounded peak memory, and the throughput win from concurrency shows up on GPU (overlapping host<->device) or I/O-bound inputs. Tune `BATCH_N` / `ROUNDS` via env.

## Ecosystem

ppu-paddle-ocr is part of a family of document-processing libraries for JavaScript runtimes, all from [PT Perkasa Pilar Utama](https://github.com/PT-Perkasa-Pilar-Utama):

| Library                                                                                      | What it does                                                                                                    |
| :------------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------- |
| [ppu-ocv](https://github.com/PT-Perkasa-Pilar-Utama/ppu-ocv)                                 | Chainable image processing on OpenCV.js, plus canvas utilities that run in Node, Bun, browsers, and extensions. |
| [ppu-pdf](https://github.com/PT-Perkasa-Pilar-Utama/ppu-pdf)                                 | PDF text extraction (digital and scanned) with coordinates, line grouping, and page-to-canvas/PNG rendering.    |
| [ppu-doclayout](https://github.com/PT-Perkasa-Pilar-Utama/ppu-doclayout)                     | Document layout analysis with PaddlePaddle PP-DocLayout (tables, figures, text regions).                        |
| [ppu-doc-correction](https://github.com/PT-Perkasa-Pilar-Utama/ppu-doc-correction)           | Document image correction: page orientation, geometric unwarping (UVDoc), and text-line orientation.            |
| [ppu-uniface](https://github.com/PT-Perkasa-Pilar-Utama/ppu-uniface)                         | Face detection, recognition, verification, alignment, and anti-spoofing (a port of Python's Uniface).           |
| [ppu-yolo-onnx-inference](https://github.com/PT-Perkasa-Pilar-Utama/ppu-yolo-onnx-inference) | YOLOv11 object detection in Bun/Node and browsers; no Python or PyTorch required.                               |

## Contributing

See [CONTRIBUTING.md](CONTRIBUTING.md) for setup instructions, code-quality requirements, and the pull request process.

## License

MIT. See [LICENSE](LICENSE).

## Support

[Open an issue](https://github.com/PT-Perkasa-Pilar-Utama/ppu-paddle-ocr/issues) or join our [Slack community](https://join.slack.com/t/ppupaddleocrcommunity/shared_invite/zt-3uzp1uuma-lrkEq8OYBYhGdUtzRoVmUg).

## Scripts

Recommended development environment is Linux-based. Library template: https://github.com/aquapi/lib-template

To run a specific benchmark file:

```bash
bun task bench index     # Run bench/index.bench.ts
bun task bench --node    # Run all benchmarks with Node.js
```

ppu-paddle-ocr

Explore Similar Repositories

Was this content helpful?

Recent Feedback

Download README