rusto-rs

🎯 Key Features

• Pure Rust MNN Engine (rusto-nn) — Zero C++ or OpenCV runtime dependencies. SIMD vectorization (AVX-512, AVX2, NEON, WASM SIMD128) with pluggable RTen, ONNX, and hardware backends (WebGPU, CUDA). Build directly with cargo build.
• Flagship Indra OCR + PP-OCRv6 — DataLab Indra OCR (~5.4 MB, 45.97% OmniDocBench accuracy) by default alongside PP-OCRv6 (50+ languages unified), PP-OCRv5, and PP-OCRv4 (FP32 & INT8).
• End-to-End Document Pipeline — Built-in 3D UVDoc unwarping, orientation detection, PicoDet layout region classification (regionId / layoutType), and neural graph reading order (indra_order.rten).
• Unified Fluent Builder API — Consistent .withAutoUnwarp(), .withLayoutReading(), .asLines() / .asWords() / .asSpatial() / .asTsv(), and single .run() terminal execution across every SDK.
• 12 Cross-Platform SDKs + CLI — First-class libraries for Rust, Node.js, Python, Go, Java, .NET, Dart, Flutter, Web (WASM), React, React Native, iOS, Android, and C FFI, plus the rusto CLI.

📦 Packages

⚠️ Notable Breaking Changes in v0.4.0

Upgrading from v0.3.x to v0.4.0 introduces a unified fluent builder API, 6-phase pipeline options, pipelined document layout/unwarping, and Indra OCR as the default flagship engine:

👉 Read the Complete v0.3 → v0.4 Migration Guide for code comparisons, API changes, and step-by-step instructions.

🚀 Quick Start by Language

1. Rust

use rusto::{DetectTextBuilderExt, ImageSource, InitializeConfig, RustO};

let mut ocr = RustO::initialize(InitializeConfig::default())?;
let result = ocr
    .detect_text_builder(ImageSource::Path("document.jpg".into()))
    .with_auto_unwarp(true)
    .with_layout_reading(true)
    .as_lines()
    .run()?;
println!("{result:?}");

2. .NET / C#

using RustODotnet;

using var ocr = RustO.Initialize();
var result = ocr.DetectText("invoice.jpg")
    .WithAutoUnwarp()
    .WithLayoutReading()
    .AsLines()
    .Run();

if (result is StructuredDetectTextResult structured) {
    foreach (var item in structured.Items) {
        Console.WriteLine($"{item.Text} ({item.Score:F2})");
    }
}

3. Web (WASM / Browser)

npm install @rustors/web

import { initialize, detectText } from '@rustors/web';

await initialize({
  preset: 'indra',
  models: {
    detection: '/models/indraocr/det.rten',
    recognition: '/models/indraocr/rec.rten',
    dictionary: '/models/indraocr/dict.txt',
  },
});

const results = await detectText(document.querySelector('img')!)
  .withAutoUnwarp()
  .withLayoutReading()
  .asLines()
  .run();

results.forEach((r) => console.log(`${r.text} (${r.score})`));

4. React

npm install @rustors/react @rustors/web

import { RustoProvider, useOcr } from '@rustors/react';

const models = {
  detection: '/models/indraocr/det.rten',
  recognition: '/models/indraocr/rec.rten',
  dictionary: '/models/indraocr/dict.txt',
};

function OcrScanner() {
  const { detect, results, isProcessing } = useOcr();

  return (
    <div>
      <input
        type="file"
        onChange={(e) =>
          e.target.files?.[0] &&
          detect(e.target.files[0], { autoUnwarp: true, layoutReading: true })
        }
      />
      {isProcessing && <p>Scanning...</p>}
      {results.map((r, i) => (
        <p key={i}>
          {r.text} ({r.score.toFixed(2)})
        </p>
      ))}
    </div>
  );
}

export function App() {
  return (
    <RustoProvider config={{ preset: 'indra', models }}>
      <OcrScanner />
    </RustoProvider>
  );
}

5. React Native

npm install @rustors/react-native

import { initialize, detectText } from '@rustors/react-native';

await initialize();
const results = await detectText({ uri: 'file:///path/to/image.jpg' })
  .withAutoUnwarp()
  .withLayoutReading()
  .asLines()
  .run();

results.forEach((r) => console.log(`${r.text} (${r.score})`));

6. iOS (Swift)

let ocr = try RustO.initialize()
let result = try ocr.detectText(image: "receipt.jpg")
    .withAutoUnwarp()
    .withLayoutReading()
    .asLines()
    .run()

if case .structured(let items) = result {
    items.forEach { print("\($0.text) (\($0.score))") }
}

7. Android (Kotlin)

RustO.initialize(context).use { ocr ->
    val result = ocr.detectText("/path/to/image.jpg")
        .withAutoUnwarp()
        .withLayoutReading()
        .asLines()
        .run()

    if (result is DetectTextResult.Structured) {
        result.items.forEach { println("${it.text} (${it.score})") }
    }
}

8. Node.js (N-API)

npm install @rustors/node

const { RustO } = require('@rustors/node');

const engine = RustO.initialize();
const results = engine
  .detectText('invoice.png')
  .withAutoUnwarp()
  .withLayoutReading()
  .asLines()
  .run();

results.forEach((r) => console.log(`${r.text} (${(r.score * 100).toFixed(1)}%)`));
engine.close();

9. Python (UniFFI)

pip install rusto

from rusto import RustO

with RustO.initialize() as engine:
    result = (
        engine.detect_text("invoice.png")
        .with_auto_unwarp()
        .with_layout_reading()
        .as_lines()
        .run()
    )

    if result.is_STRUCTURED():
        for item in result.results:
            print(f"{item.text} ({item.score:.2f})")

10. Golang (Cgo)

go get github.com/byrizki/rusto-rs/packages/go

package main

import (
    "fmt"
    "github.com/byrizki/rusto-rs/packages/go"
)

func main() {
    engine, err := rusto.Initialize()
    if err != nil { panic(err) }
    defer engine.Close()

    res, err := engine.DetectText("invoice.png").
        WithAutoUnwarp(true).
        WithLayoutReading(true).
        AsLines().
        Run()
    if err != nil { panic(err) }

    for _, r := range res.Results {
        fmt.Printf("[%0.2f] %s\n", r.Score, r.Text)
    }
}

11. Java (JVM / JNA)

import com.byrizki.rusto.RustO;
import com.byrizki.rusto.TextResult;

public class App {
    public static void main(String[] args) {
        try (RustO engine = RustO.initialize()) {
            RustO.DetectTextResult res = engine.detectText("invoice.png")
                .withAutoUnwarp()
                .withLayoutReading()
                .asLines()
                .run();
            for (TextResult r : res.results()) {
                System.out.printf("[%0.2f] %s%n", r.score(), r.text());
            }
        }
    }
}

12. Dart & Flutter

import 'package:rusto/rusto.dart';

final engine = RustO.initialize();
final result = engine
    .detectText('invoice.png')
    .withAutoUnwarp()
    .withLayoutReading()
    .asLines()
    .run();

if (result is DetectTextResultStructured) {
  for (final line in result.results) {
    print('${line.text} (${line.score})');
  }
}
engine.close();

13. Command Line Interface (CLI)

# Zero-config OCR (auto-downloads Indra OCR models on first run)
rusto image.jpg

# Multi-column layout reading order & 2D spatial text reconstruction
rusto --enable-unwarp --enable-layout --format spatial image.jpg

# Pre-download standalone RTen models for offline environments
rusto download --model indraocr

🧠 Supported OCR Models & Tiers

RustO! supports DataLab Indra OCR as its default flagship engine alongside PP-OCRv6 (recognizing 50+ languages simultaneously) and legacy v5/v4 models:

Pre-trained models are distributed as standalone assets on Hugging Face Hub (byrizki/rusto-models) with native CORS support and downloaded automatically on first run by the CLI and native SDKs.

👉 View Complete Multilingual OCR Guide & Model Matrix

⚙️ Configuration & Runtime Options

RustO separates static initialization from per-request execution:

1. InitializeConfig — Configures model sessions, vocabulary dictionary, and hardware threads.
2. DetectTextBuilder / OcrRunOptions — Configures per-image options via fluent chaining: 4 toggles (autoUnwarp, layoutReading, orientationDetection, lineClassification) and 6 phases (preDetection, detection, postDetection, preRecognition, recognition, postRecognition).

use rusto::{DetectTextBuilderExt, ImageSource, InitializeConfig, RustO};

// 1. Initialize engine once (or RustO::initialize(InitializeConfig::default())? for auto-download)
let mut ocr = RustO::initialize(InitializeConfig::indra(
    "models/det.rten",
    "models/rec.rten",
    "models/dict.txt",
))?;

// 2. Configure per request via fluent builder chaining
let result = ocr
    .detect_text_builder(ImageSource::Path("document.jpg".into()))
    .with_auto_unwarp(true)
    .with_layout_reading(true)
    .as_spatial()
    .run()?;

👉 Read the Full API Reference & Option Specifications

📖 Documentation & Advanced Guides

Explore deep-dive guides and comprehensive references on the RustO! Documentation Site:

⚡ Performance & Benchmarks

Empirically evaluated against official PaddleOCR and RapidOCR (C++ ONNX Runtime) using the standard OmniDocBench dataset and high-resolution document scans (1600×993 px, 27 text lines).

Benchmark Hardware: 11th Gen Intel(R) Core(TM) i7-1185G7 @ 3.00GHz (4 cores / 8 threads), 32 GB RAM, Linux x86_64.

📁 Repository Structure

rusto-rs/
├── crates/
│   ├── rusto-nn/               # Pure-Rust neural inference runtime & hardware backends
│   ├── rusto-core/             # Core OCR pipeline (DBNet, CTC, UVDoc unwarp, PicoDet layout, reading order)
│   ├── rusto-rten/             # RTen (.rten) session backend
│   ├── rusto-mnn/              # Optional MNN C++ session backend
│   ├── rusto-node/             # Native Node.js N-API addon crate
│   └── rusto-wasm/             # Browser WebAssembly OCR & layout runtime
├── src/                        # Workspace root crate, UniFFI/C FFI bridges & `rusto` CLI
├── include/                    # Canonical C header (`rusto.h`)
├── packages/
│   ├── node/                   # @rustors/node (Node.js N-API SDK)
│   ├── python/                 # rusto (Python UniFFI SDK)
│   ├── go/                     # Go Cgo module
│   ├── java/                   # rusto-java (JVM JNA SDK)
│   ├── dotnet/                 # RustODotnet (.NET / C# SDK)
│   ├── dart/                   # rusto (Pure Dart FFI SDK)
│   ├── flutter/                # rusto_flutter (Flutter plugin)
│   ├── web/                    # @rustors/web (Browser WASM SDK)
│   ├── react/                  # @rustors/react (React hooks & components)
│   ├── react-native/           # @rustors/react-native (iOS & Android bridge)
│   ├── android/                # rusto-android (Kotlin Android AAR)
│   └── ios/                    # RustO (Swift Package Manager & CocoaPods)
├── docs/                       # Bilingual documentation site & live WASM demo (EN / ID)
├── scripts/                    # Version bump, UniFFI codegen & package verification scripts
└── .github/workflows/          # CI, cross-platform artifact build & automated registry publishing

🛠️ Development & Testing

# Run core library unit tests across the workspace
cargo test --workspace --lib

# Build the `rusto` CLI in release mode
cargo build --release --bin rusto

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

🛡️ Security & Snyk Partnership

RustO! is a community-driven open source project protected and monitored with the support of the Snyk Open Source Program. Snyk provides automated developer security tooling to detect, track, and remediate vulnerabilities across our Rust engine, dependencies, container environments, and multi-platform packages.

• Vulnerability Status:
• Reporting Vulnerabilities: If you discover a security issue or vulnerability, please refer to our Security Policy for responsible disclosure steps.
• Co-branding Grant: We hereby grant Snyk permission and a non-exclusive license to use, reproduce, and display the RustO! project logo and related project content on Snyk's website and marketing materials in accordance with the Snyk Open Source Program.

📄 License

This project is licensed under the MIT License.

🙏 Acknowledgments

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

• DataLab — Creators of Indra OCR models and the OmniDocBench evaluation dataset
• RapidOCR — Architecture and OCR pipeline reference
• PaddleOCR — Pretrained OCR models (PP-OCRv6, PP-OCRv5, PP-OCRv4)
• Alibaba MNN — Pioneered efficient mobile deep learning formats, executed natively in pure Rust via rusto-nn
• RTen — Pure Rust deep learning inference engine supported in RustO!
• Snyk — Developer security and vulnerability monitoring through the Snyk Open Source Program
• 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 pure Rust MNN (rusto-nn) inference}
}