RustO! 🦀

High-Performance, Pure Rust OCR Engine & Multi-Platform Toolkit

RustO! is a high-performance Optical Character Recognition (OCR) engine and cross-platform toolkit written in pure Rust. Based on RapidOCR and powered by PaddleOCR models with Alibaba's MNN lightweight inference backend, RustO! delivers sub-second inference speeds, ultra-low memory overhead, and 99.3%+ parity with OpenCV-based solutions.

🎯 Key Features

• 🚀 Pure Rust Core — Zero OpenCV dependency. Includes pure Rust image processing, DBNet polygon contour detection, and unclip algorithms.
• ⚡ Blazing Fast & Lightweight — Powered by the lightweight MNN inference engine, optimized with link-time optimization (LTO) and single codegen unit compilation.
• 📄 Spatial Layout Text Reconstruction — Reconstructs human-readable document layouts (multi-column tables, invoices, forms) with configurable visual XY spatial spacing.
• 🧠 Full Model Series Support — Seamless support for PP-OCRv6 (Tiny, Small, Medium), PP-OCRv5 (Mobile, Server), and PP-OCRv4 (Mobile, Server) with orientation classification.
• 📦 Modular Distribution — Core runtimes are stripped of forced model bloat. Users can choose pre-packaged model tiers or bring their own custom models.
• 🌐 First-Class Cross-Platform SDKs — Ready-to-use packages for Rust, .NET / C#, React Native, iOS (Swift), Android (Kotlin), and C FFI.

📦 Multi-Platform Packages Ecosystem

🚀 Quick Start by Language

1. Rust

use rusto::{DetectTextResult, ImageSource, OcrRunOptions, RustO, InitializeConfig};

let mut ocr = RustO::initialize(InitializeConfig::ppv6("det.mnn", "rec.mnn", "dict.txt"))?;
match ocr.detect_text(&ImageSource::Path("document.jpg".into()), &OcrRunOptions::default())? {
    DetectTextResult::Structured(results) => println!("{:?}", results),
    DetectTextResult::Spatial(text) => println!("{text}"),
}

2. .NET / C#

using var ocr = RustO.Initialize();
var result = ocr.DetectText(new UriImageSource("invoice.jpg"));

3. React Native

Install the npm package and choose your model package for iOS and Android:

npm install react-native-rusto
# or yarn add react-native-rusto / pnpm add react-native-rusto

iOS Setup (ios/Podfile):

target 'YourApp' do
  # Add your preferred OCR model package:
  pod 'RustO-Models-PPOCRv6-Tiny'     # ~6 MB (Recommended default)
  # or pod 'RustO-Models-PPOCRv6-Small'
  # or pod 'RustO-Models-PPOCRv5-Mobile'
end

cd ios && pod install

Android Setup (android/app/build.gradle):

dependencies {
    // Add your preferred OCR model package:
    implementation 'com.github.byrizki.rusto-rs:rusto-models-ppocrv6-tiny:v0.2.2'
}

JavaScript / TypeScript Usage:

import { initialize, detectText } from 'react-native-rusto';

// Initialize bundled default models once.
await initialize();

// `{ uri }` accepts an absolute path, file: URI, or Android content:// URI.
const results = await detectText(
  { uri: '/path/to/image.jpg' },
  { output: 'lines', lineYThreshold: 0.5, wordXThreshold: 0.4 },
);
results.forEach((r) => {
  console.log(`${r.text} (${r.score}) - Frame:`, r.frame);
});

// Spatial layout text comes from same API.
const spatialText = await detectText(
  { uri: '/path/to/image.jpg' },
  { output: 'spatial', lineYThreshold: 0.5, wordXThreshold: 0.4 },
);
console.log(spatialText);

4. iOS (Swift)

let ocr = try RustO.initialize()
let result = try ocr.detectText(.uri("receipt.jpg"))

5. Android (Kotlin)

val ocr = RustO.initialize(context)
val result = ocr.detectText(ImageSource.Uri("/path/to/image.jpg"))

6. Command Line Interface (CLI)

# JSON output (default)
cargo run --release -- --det-model det.mnn --rec-model rec.mnn --dict dict.txt image.jpg

# Ordered text output
cargo run --release -- --det-model det.mnn --rec-model rec.mnn --dict dict.txt --format text-ordered image.jpg

# TSV / Plain text output
cargo run --release -- --det-model det.mnn --rec-model rec.mnn --dict dict.txt --format tsv image.jpg

🧠 Supported OCR Models & Tiers

RustO! supports all PaddleOCR model series in lightweight MNN format:

🌐 Multi-Language Support Across Model Versions

• PP-OCRv6 (Recommended Default): Uses a unified 50-language dictionary (ppocrv6_dict.txt) and multilingual model architecture. All language scripts (Latin, Cyrillic, CJK, Devanagari, Arabic, etc.) are supported out-of-the-box in the base PPOCRv6 packages without needing separate language model downloads.
• PP-OCRv5 & PP-OCRv4: Use dedicated language recognition models (rec.mnn + dict.txt) for specific non-Chinese scripts. Text detection (det.mnn) remains language-agnostic.

PP-OCRv5 Language Packages

Additional PP-OCRv4 Language Models (Available via Downloader)

PP-OCRv4 includes additional specialized language models on ModelScope (e.g. Japanese, Traditional Chinese, Kannada):

Downloading Models on the Fly

You can use the built-in downloader to fetch pre-converted MNN models directly from ModelScope RapidOCR:

# Download all models for all tiers and languages
bash scripts/download_models.sh --all

# Download specific model tier
bash scripts/download_models.sh --model ppocrv6 --tier tiny --output-dir models/PPOCR_v6
bash scripts/download_models.sh --model ppocrv5 --tier mobile --output-dir models/PPOCR_v5
bash scripts/download_models.sh --model ppocrv4 --tier mobile --output-dir models/PPOCR_v4

# Download specific language model
bash scripts/download_models.sh --model ppocrv5 --lang arabic --output-dir models/PPOCR_v5_arabic

⚙️ Configuration Reference (InitializeConfig)

InitializeConfig provides granular control over the OCR pipeline:

use rusto::InitializeConfig;

let config = InitializeConfig::ppv6("models/det.mnn", "models/rec.mnn", "models/dict.txt")
    // Detection parameters
    .with_det_thresh(0.3)          // Pixel binarization threshold
    .with_det_box_thresh(0.6)      // Box confidence threshold
    .with_limit_side_len(736)      // Max input side length for detection
    .with_limit_type("min")        // Resize strategy ("min" or "max")
    .with_unclip_ratio(2.0)        // Expansion ratio for detected text polygons
    .with_use_dilation(true)       // Morphological dilation for segmented lines
    
    // Recognition & Spatial tuning
    .with_text_score(0.5)          // Minimum character confidence score
    .with_xy_threshold(0.5, 1.0)   // (y_multiplier, x_multiplier) for spatial layout
    .with_rec_batch_num(6)         // Batch size for text recognition
    
    // Optional modules
    .with_cls("models/cls.mnn", 0.9)            // Direction / orientation classifier
    .with_orientation("models/orient.mnn", 0.9) // Document angle rotator
    .with_unwarp("models/unwarp.mnn");          // Document shadow/curve unwarper

Template Presets

• InitializeConfig::ppv6(...) — Pre-configured for PP-OCRv6 (limit_side_len=736, limit_type="min", unclip_ratio=2.0)
• InitializeConfig::ppv5(...) — Pre-configured for PP-OCRv5 (limit_side_len=736, limit_type="min", unclip_ratio=2.0)
• InitializeConfig::ppv4(...) — Pre-configured for PP-OCRv4 (limit_side_len=960, limit_type="max", unclip_ratio=1.5)
• InitializeConfig::ppv3(...) — Pre-configured for PP-OCRv3 (limit_side_len=960, limit_type="max", unclip_ratio=1.5)

⚡ Performance & Benchmarks

Tested on standard document images across platforms:

📁 Repository Structure

rusto-rs/
├── src/                        # Rust Core Engine
│   ├── lib.rs                  # Public API & exports
│   ├── config.rs               # InitializeConfig & template presets (PPV6, PPV5, PPV4, PPV3)
│   ├── det.rs                  # DBNet text detection
│   ├── rec.rs                  # CTC text recognition
│   ├── orient.rs               # Orientation classification
│   ├── preprocess.rs           # Pure Rust image preprocessing & normalization
│   ├── postprocess.rs          # Polygon unpacking & spatial layout reconstruction
│   ├── contours.rs             # Pure Rust contour detection (OpenCV-free)
│   ├── geometry.rs             # Geometric transforms, box rectification & NMS
│   └── ffi.rs                  # C FFI shared library interface
├── packages/
│   ├── dotnet/                 # .NET / C# SDK (RustODotnet + Model Packages)
│   ├── react-native/           # React Native TypeScript + iOS/Android Bridge
│   ├── android/                # Android Kotlin SDK + Modular Model AARs
│   └── ios/                    # iOS Swift SDK + Modular Model Podspecs
├── scripts/
│   └── download_models.sh      # Direct ModelScope model downloader
└── .github/workflows/
    ├── build.yml               # Parallel CI build & artifact packaging
    └── publish.yml             # Automated multi-registry package publishing

🛠️ Development & Testing

# Run unit & integration tests
cargo test

# Run tests with optional OpenCV verification backend
cargo test --features use-opencv

# Run benchmarks
cargo bench

# Run linter & formatter
cargo clippy
cargo fmt --check

📄 License

This project is licensed under the MIT License.

🙏 Acknowledgments

RustO! is inspired by and builds upon the incredible work of:

• RapidOCR — Architecture and OCR pipeline reference
• PaddleOCR — State-of-the-art OCR models (PP-OCRv6, PP-OCRv5, PP-OCRv4)
• Alibaba MNN — Ultra-fast, lightweight deep learning inference engine
• Rust Community — image, imageproc, nalgebra, and rayon crates

📝 Citation

If you use RustO! in your research or commercial application, please consider citing:

@software{rusto2024,
  title = {RustO! - High-Performance Pure Rust OCR Library},
  author = {Rizki & Contributors},
  year = {2024},
  url = {https://github.com/byrizki/rusto-rs},
  note = {Based on RapidOCR and powered by PaddleOCR models with MNN inference}
}