ruvector/examples/scipix/docs/02_OCR_RESEARCH.md

AI-Driven OCR Research: Mathematical Expression Recognition

Research Date: November 28, 2025 Focus: State-of-the-art Vision Language Models for Mathematical OCR Target Implementation: Rust + ONNX Runtime

Executive Summary

Mathematical OCR has undergone a paradigm shift in 2025, with Vision Language Models (VLMs) replacing traditional pipeline-based approaches. The field saw explosive growth with six major open-source models released in October 2025 alone. Current state-of-the-art achieves 98%+ accuracy on printed text and 80-95% on handwritten mathematical expressions, with transformer-based architectures (ViT + Transformer decoder) significantly outperforming traditional CNN-RNN pipelines.

---

1. Evolution of OCR Technology

1.1 Traditional OCR (Pre-2015)

• Rule-based approaches: Template matching, connected component analysis
• Feature extraction: HOG, SIFT descriptors
• Classification: SVM, k-NN classifiers
• Limitations: Fixed templates, poor generalization, manual feature engineering
• Math support: Virtually non-existent for complex expressions

1.2 Deep Learning Era (2015-2024)

• CNN-RNN pipelines: Convolutional feature extraction + LSTM sequence modeling
• Attention mechanisms: Bahdanau/Luong attention for alignment
• Encoder-decoder architectures: Seq2seq models for LaTeX generation
• Notable models: Tesseract OCR 4.0 (LSTM-based), CRNN, Show-Attend-and-Tell
• Im2latex-100k dataset: Enabled supervised learning for mathematical OCR
• Challenges: Multi-stage pipelines, separate detection/recognition, limited context understanding

1.3 Vision Language Model Revolution (2024-2025)

• End-to-end architectures: Single model for detection, recognition, and structure understanding
• Transformer-based: Vision Transformer (ViT) encoders + Transformer decoders
• Multimodal compression: Images as compressed vision tokens (7-20× token reduction)
• Contextual reasoning: LLM-powered understanding of mathematical structure
• October 2025 explosion: 6 major models released:
  • Nanonets OCR2-3B
  • PaddleOCR-VL-0.9B
  • DeepSeek-OCR-3B
  • Chandra-OCR-8B
  • OlmOCR-2-7B
  • LightOnOCR-1B

Key insight: VLMs treat OCR as a multimodal compression problem rather than pure pattern recognition, enabling superior context understanding and mathematical structure preservation.

---

2. Current State-of-the-Art Models

2.1 DeepSeek-OCR (October 2025)

Architecture:

• Size: 3B parameters (570M active parameters per token via MoE)
• Decoder: Mixture-of-Experts language model
• Approach: Vision-centric compression (images → vision tokens → text)
• Token efficiency: 7-20× reduction vs. classical text processing
• Vision tokens: Only 100 tokens per page

Performance:

• Accuracy: 97% overall, 96%+ at 9-10× compression, 90%+ at 10-12× compression
• Mathematical OCR: Successfully extracts LaTeX from equations with proper structure
• Speed: Faster than pipeline-based approaches (single model call)
• Limitations: Struggles with polar coordinates recognition, table structure parsing

Mathematical capabilities:

• Detects and extracts multiple equations from single image
• Outputs clean LaTeX with \frac, proper variable formatting
• Handles fractions, subscripts, superscripts, integrals, summations
• Maintains mathematical structure for direct reuse

Adoption:

• 4k+ GitHub stars in <24 hours
• 100k+ downloads
• Supported in upstream vLLM (October 23, 2025)
• Open-source: Apache 2.0 license

ONNX compatibility: Not officially available, but architecture (ViT + Transformer) is ONNX-exportable

2.2 dots.ocr (July 2025)

Architecture:

• Size: 1.7B parameters
• Design: Unified transformer for layout + content recognition
• Base model: dots.ocr.base (foundation VLM for OCR tasks)
• Language support: 100+ languages

Key innovations:

• Single model approach: Eliminates separate detection/OCR pipelines
• Task switching: Adjust input prompts to change recognition mode
• Multilingual: Best-in-class for diverse language document parsing

Performance:

• Accuracy: SOTA on multilingual document parsing benchmarks
• Speed: Slower than DeepSeek (pipeline-based approach)
• Use case: Complex multilingual documents with mixed layouts

Trade-offs:

• Multiple model calls per page (detection, then recognition)
• Additional cropping and preprocessing overhead
• Higher quality through specialized heuristics

ONNX compatibility: VLM architecture is ONNX-exportable with Hugging Face Optimum

2.3 PaddleOCR 3.0 + PaddleOCR-VL (2025)

Architecture:

• PP-OCRv5: High-precision text recognition pipeline
• PP-StructureV3: Hierarchical document parsing
• PP-ChatOCRv4: Key information extraction
• PaddleOCR-VL-0.9B: Compact VLM with dynamic resolution

PaddleOCR-VL-0.9B design:

• Visual encoder: NaViT-style dynamic resolution
• Language model: ERNIE-4.5-0.3B
• Pointer network: 6 transformer layers for reading order
• Languages: 109 languages supported
• Size advantage: 0.9B parameters vs. 70-200B for competitors

Performance:

• Accuracy: Competitive with billion-parameter VLMs
• Speed: 2.67× faster than dots.ocr, slower than DeepSeek (1.73×)
• Efficiency: Best accuracy-to-parameter ratio
• Mathematical recognition: Outperforms DeepSeek-OCR-3B on certain formulas

Deployment:

• Lightweight models (<100M parameters) for edge devices
• Can work in tandem with large models
• Production-ready with comprehensive tooling

ONNX compatibility: ✅ EXCELLENT - Native ONNX support via PaddlePaddle

• oar-ocr Rust library uses PaddleOCR ONNX models
• paddle-ocr-rs provides Rust bindings
• Pre-trained ONNX models available

2.4 LightOnOCR-1B (2025)

Architecture:

• Size: 1B parameters
• Design: End-to-end domain-specific VLM
• Efficiency focus: Optimized for speed without sacrificing accuracy

Performance:

• Speed leader: 6.49× faster than dots.ocr, 2.67× faster than PaddleOCR-VL, 1.73× faster than DeepSeek-OCR
• Single model call: No pipeline overhead
• Trade-off: May sacrifice some quality vs. multi-stage pipelines

ONNX compatibility: VLM architecture, likely ONNX-exportable

2.5 Mistral OCR & HunyuanOCR (2025)

HunyuanOCR:

• Lightweight VLM with unified end-to-end architecture
• Vision Transformer + lightweight LLM
• State-of-the-art performance in OCR tasks
• Emphasis on efficiency

ONNX compatibility: Depends on specific implementation details

---

3. Mathematical OCR Architectures

3.1 Vision Transformer (ViT) Encoders

Architecture:

Input Image (224×224 or 384×384)
    ↓
Patch Embedding (16×16 patches → 768D embeddings)
    ↓
Positional Encoding (learnable or sinusoidal)
    ↓
Transformer Encoder Layers (12-24 layers)
    ↓ [Multi-head Self-Attention + FFN]
    ↓
Vision Tokens (compressed image representation)

Advantages for math OCR:

• Global context: Self-attention captures long-range dependencies (crucial for fractions, matrices)
• Adaptive receptive field: Attends to relevant symbols regardless of spatial distance
• No CNN limitations: No fixed receptive field or pooling-induced information loss
• Scalability: Easily scales to higher resolutions for complex expressions

Implementation considerations:

• Patch size: 16×16 standard, 8×8 for higher detail mathematical symbols
• Resolution: 384×384 or higher for small subscripts/superscripts
• Pre-training: ImageNet-21k or self-supervised (MAE, DINO)

3.2 Transformer Decoders for LaTeX Generation

Architecture:

Vision Tokens (from ViT encoder)
    ↓
Cross-Attention (decoder queries attend to vision tokens)
    ↓
Causal Self-Attention (autoregressive LaTeX generation)
    ↓
Feed-Forward Network
    ↓
LaTeX Token Prediction (vocabulary: ~500-1000 LaTeX commands)

Key mechanisms:

• Autoregressive generation: Predict next LaTeX token given previous tokens
• Cross-attention: Align LaTeX tokens with image regions (e.g., \frac attends to fraction bar)
• Causal masking: Prevent looking ahead during training
• Beam search: Generate multiple candidate LaTeX strings, select best

LaTeX vocabulary design:

• Command tokens: \frac, \int, \sum, \begin{matrix}
• Symbol tokens: Greek letters, operators, delimiters
• Alphanumeric tokens: Variables, numbers
• Special tokens: <BOS>, <EOS>, <PAD>, <UNK>

3.3 Hybrid CNN-ViT Architectures

pix2tex/LaTeX-OCR approach:

Input Image
    ↓
ResNet Backbone (CNN feature extraction)
    ↓ [Conv layers, residual blocks]
    ↓
ViT Encoder (refine features with self-attention)
    ↓
Transformer Decoder (LaTeX generation)
    ↓
LaTeX String

Rationale:

• CNN: Low-level feature extraction (edges, textures) - efficient for local patterns
• ViT: High-level reasoning with global context
• Best of both worlds: CNN inductive biases + Transformer flexibility

pix2tex details:

• ~25M parameters
• Trained on Im2latex-100k (~100k image-formula pairs)
• ResNet backbone + ViT encoder + Transformer decoder
• Automatic image resolution prediction for optimal performance

3.4 Graph Neural Networks (Emerging)

Motivation: Mathematical expressions are inherently graph-structured (tree-based)

Architecture:

Input Image → Symbol Detection → Symbol Classification
    ↓
Graph Construction (nodes = symbols, edges = spatial relationships)
    ↓
GNN (message passing to infer structure)
    ↓
Tree Reconstruction → LaTeX Generation

Advantages:

• Structure-aware: Explicitly models hierarchical relationships
• Interpretable: Intermediate graph representation
• Error correction: GNN can fix symbol detection errors via context

Current status: Research phase, not yet production-ready

3.5 Pointer Networks for Reading Order

PaddleOCR-VL approach:

• 6 transformer layers to determine element reading order
• Outputs spatial map + reading sequence
• Crucial for multi-line equations, matrices, cases

3.6 Architecture Comparison

Architecture	Parameters	Strengths	Weaknesses	ONNX Support
CNN-RNN (CRNN)	10-50M	Fast, lightweight	Limited context, sequential bottleneck	✅ Excellent
ViT + Transformer	25M-3B	Global context, SOTA accuracy	Compute-intensive, requires large data	✅ Good (via Optimum)
Hybrid CNN-ViT	25-100M	Balanced efficiency/accuracy	More complex training	✅ Good
VLM (multimodal)	0.9B-3B	Best accuracy, contextual reasoning	Large models, slower inference	⚠️ Limited (model-specific)
GNN-based	50-200M	Structure-aware, interpretable	Research phase, requires graph labels	❌ Limited

---

4. Key Datasets for Mathematical OCR

4.1 Im2latex-100k (Standard Benchmark)

Overview:

• Size: ~100,000 image-formula pairs
• Source: LaTeX formulas from arXiv, Wikipedia
• Type: Computer-generated (rendered LaTeX)
• Splits: Train (~84k), Validation (~9k), Test (~10k)

Characteristics:

• Quality: High-quality rendered formulas
• Diversity: Wide variety of mathematical domains
• Realism: Lower (no handwriting, perfect rendering)

Benchmark status:

• De facto standard for typeset math OCR
• Current SOTA: I2L-STRIPS model
• Typical BLEU scores: 0.67-0.73

Training use:

• Supervised learning for LaTeX generation
• Pre-training for more complex datasets
• Evaluation standard for all new models

4.2 Im2latex-230k (Extended Dataset)

Overview:

• Size: 230,000 image-formula pairs
• Source: Extended Im2latex-100k with additional arXiv formulas
• Type: Computer-generated

Advantages:

• More training data for better generalization
• Covers more edge cases and rare symbols
• Reduced overfitting risk

Availability: Publicly available via OpenAI's Requests for Research

4.3 MathWriting (Handwritten, 2025)

Overview:

• Size: 230k human-written + 400k synthetic = 630k total
• Type: Online handwritten mathematical expressions
• Released: 2025 (ACM SIGKDD Conference)
• Status: Largest handwritten math dataset to date

Significance:

• Handwriting variation: Real human writing styles, speeds, devices
• Synthetic augmentation: 400k examples for data augmentation
• Bridge the gap: Enables training on handwritten → LaTeX
• Practical use cases: Tablet input, educational apps

Challenges addressed:

• Stroke order variations
• Ambiguous symbols (1 vs. l vs. I, 0 vs. O)
• Incomplete or messy handwriting
• Variable symbol sizes and alignment

4.4 HME100K (Handwritten Math Expressions)

Overview:

• 100k handwritten mathematical expressions
• Used in OCRBench v2 evaluation
• Combines with other datasets for comprehensive benchmarking

4.5 MLHME-38K (Multi-Line Handwritten Math)

Overview:

• 38k multi-line handwritten expressions
• Focuses on complex, multi-step equations
• Tests layout understanding and reading order

4.6 M2E (Math Expression Evaluation)

Overview:

• Specialized dataset for evaluating mathematical expression recognition
• Includes challenging cases and edge scenarios

4.7 Dataset Comparison

Dataset	Size	Type	Handwritten	Multi-line	Public	Best Use Case
Im2latex-100k	100k	Rendered	❌	✅	✅	Printed math OCR baseline
Im2latex-230k	230k	Rendered	❌	✅	✅	Improved printed math OCR
MathWriting	630k	Real+Synth	✅	✅	✅	Handwritten math OCR
HME100K	100k	Real	✅	❌	✅	Handwritten evaluation
MLHME-38K	38k	Real	✅	✅	✅	Multi-line handwriting

---

5. Benchmark Accuracy Comparisons

5.1 Printed Mathematical Expressions

Model	Im2latex-100k BLEU	Im2latex-100k Precision	Token Efficiency	Speed Rank
I2L-STRIPS	SOTA	73.8%	-	-
DeepSeek-OCR-3B	-	97% (general), 96%+ (9-10× compress)	100 tokens/page	🥇 Fastest
pix2tex (LaTeX-OCR)	0.67	-	-	Fast
TexTeller	Higher than 0.67	-	-	-
PaddleOCR-VL-0.9B	-	Competitive with 70B VLMs	-	Fast
LightOnOCR-1B	-	Competitive	-	🥇🥇 Fastest

Key findings:

• BLEU scores: 0.67-0.73 typical for state-of-the-art
• Precision: 97-98%+ for printed text, 73-97% for complex formulas
• Token efficiency: VLMs achieve 7-20× compression vs. text-based approaches
• Speed-accuracy trade-off: Smaller models (0.9B-1B) nearly match larger models (3B-70B)

5.2 Handwritten Mathematical Expressions

Model	MathWriting Accuracy	HME100K Accuracy	Challenges
State-of-the-art VLMs	80-95%	-	Ambiguous symbols, stroke order
Traditional OCR	<60%	-	Poor generalization, fixed templates

Key findings:

• 30-40% gap between printed (98%+) and handwritten (80-95%)
• Symbol ambiguity: Biggest challenge (1/l/I, 0/O, x/×, -/−)
• Context helps: VLMs use surrounding context to disambiguate
• Data-hungry: Requires large handwritten datasets (MathWriting 630k)

5.3 OCRBench v2 (Comprehensive Evaluation, 2025)

Evaluation criteria:

• Formula recognition (Im2latex-100k, HME100K, M2E, MathWriting, MLHME-38K)
• Layout understanding
• Reading order determination
• Multi-language support
• Visual text localization
• Reasoning capabilities

Benchmark leaders:

• PaddleOCR-VL-0.9B: Best efficiency-accuracy ratio
• DeepSeek-OCR-3B: Best token efficiency
• LightOnOCR-1B: Best speed
• dots.ocr-1.7B: Best multilingual

5.4 Speed Benchmarks (Relative Performance)

Single page inference time (normalized):

LightOnOCR-1B:        1.00× (baseline)
DeepSeek-OCR-3B:      1.73×
PaddleOCR-VL-0.9B:    2.67×
dots.ocr-1.7B:        6.49×

Key insight: End-to-end VLMs (LightOnOCR, DeepSeek) significantly outperform pipeline-based approaches (dots.ocr) in speed while maintaining comparable accuracy.

---

6. Handwriting vs. Printed Recognition Challenges

6.1 Printed Mathematical Expressions

Characteristics:

• ✅ Consistent font rendering
• ✅ Perfect alignment and spacing
• ✅ Clear symbol boundaries
• ✅ Standard LaTeX conventions

Accuracy: 98%+ with modern VLMs

Remaining challenges:

• Image quality: Low resolution, artifacts, distortion
• Font variations: Unusual or handwritten-style fonts
• Nested structures: Deep fractions, matrices within matrices
• Symbol ambiguity: Context-dependent meanings (e.g., | as absolute value, set notation, or conditional probability)

6.2 Handwritten Mathematical Expressions

Characteristics:

• ❌ High variability in writing styles
• ❌ Inconsistent symbol sizes and alignment
• ❌ Overlapping or touching symbols
• ❌ Incomplete strokes, artifacts
• ❌ Non-standard notation

Accuracy: 80-95% with modern VLMs trained on handwritten data

Major challenges:

6.2.1 Symbol Ambiguity

Ambiguous Pair	Context Clues	Failure Rate
1 / l / I	Lowercase l in variables, 1 in numbers	High
0 / O	O in variables, 0 in numbers	High
x / × / X	x in algebra, × for multiplication, X for variables	Medium
- / − / –	Hyphen vs. minus sign vs. dash	Medium
∈ / ϵ / є	Set membership vs. epsilon variations	Medium
u / ∪ / U	Variable vs. union operator vs. uppercase	Low (context helps)

Mitigation strategies:

• Contextual language models: VLMs use surrounding LaTeX to infer correct symbol
• Stroke order analysis: Online handwriting captures temporal information
• Ensemble methods: Combine multiple recognition hypotheses
• User correction feedback: Interactive systems improve over time

6.2.2 Stroke Order and Writing Speed

• Fast writing: Incomplete strokes, merged symbols
• Slow writing: Disconnected strokes, tremor artifacts
• Variable pressure: Thick/thin lines affecting segmentation

Solution: Temporal models (RNN, Transformer) process stroke sequences

6.2.3 Spatial Layout Challenges

• Fraction bars: Distinguishing from minus signs or division operators
• Superscripts/subscripts: Ambiguous vertical positioning
• Radicals: Unclear extent of √ symbol
• Parentheses matching: Incomplete or oversized brackets
• Multi-line alignment: Inconsistent equation alignment

Solution: Graph neural networks or pointer networks to model spatial relationships

6.2.4 Data Scarcity

• Printed datasets: 100k-230k easily generated from LaTeX
• Handwritten datasets: 230k+ require human annotation (expensive, time-consuming)
• Domain mismatch: Pre-training on printed, fine-tuning on handwritten

Solution: MathWriting 630k dataset (230k real + 400k synthetic augmentation)

6.3 Comparative Performance

Challenge	Printed	Handwritten	VLM Advantage
Symbol recognition	99%+	85-95%	Contextual reasoning helps handwritten
Layout understanding	98%+	80-90%	Pointer networks essential for handwritten
Multi-line equations	95%+	75-85%	Significant gap, needs more handwritten data
Ambiguous symbols	Rare	Common	VLMs use context to disambiguate
Nested structures	90%+	70-80%	Challenging for both, VLMs handle better

6.4 Recommendations for ruvector-scipix

For printed math (Scipix clone):

• ✅ Use pre-trained ViT + Transformer models (pix2tex, PaddleOCR)
• ✅ Target 98%+ accuracy achievable with current models
• ✅ ONNX-compatible models available (PaddleOCR excellent Rust support)

For handwritten math (future extension):

• ⚠️ Start with printed, add handwritten later
• ⚠️ Requires MathWriting dataset integration
• ⚠️ Fine-tune on handwritten after printed pre-training
• ⚠️ Consider stroke order data if available (tablet/stylus input)
• ⚠️ Implement user correction feedback loop

---

7. LaTeX Generation Techniques

7.1 Sequence-to-Sequence (Seq2Seq) Approaches

Architecture:

Image Encoder (CNN/ViT) → Context Vector → LaTeX Decoder (RNN/Transformer)

Mechanisms:

• Attention: Align decoder states with encoder features
• Autoregressive generation: Predict one token at a time
• Teacher forcing: Use ground truth tokens during training
• Beam search: Explore multiple generation paths during inference

Example:

Input Image: ∫₀^∞ e^(-x²) dx
Encoder Output: [v₁, v₂, ..., vₙ] (vision features)
Decoder Generation:
  t=0: <BOS> → \int
  t=1: \int → _
  t=2: _ → 0
  t=3: 0 → ^
  t=4: ^ → \infty
  ...
  t=n: dx → <EOS>
Output: \int_0^\infty e^{-x^2} dx

7.2 Multimodal Compression (VLM Approach)

DeepSeek-OCR technique:

Image → Vision Tokens (compressed) → MoE Decoder → LaTeX String

Advantages:

• Token efficiency: 7-20× reduction (100 vision tokens per page)
• Context preservation: Compressed tokens retain semantic information
• Reasoning capability: MoE decoder understands mathematical structure

Example:

Input Image: [matrix with 9 elements]
Vision Tokens: [t₁, t₂, ..., t₁₀₀] (compressed representation)
MoE Decoder Reasoning:
  - Detect matrix structure from spatial layout
  - Infer 3×3 dimensions
  - Recognize element positions
  - Generate proper LaTeX matrix syntax
Output: \begin{pmatrix} a & b & c \\ d & e & f \\ g & h & i \end{pmatrix}

7.3 Graph-Based Generation

Approach:

Image → Symbol Detection → Graph Construction → Tree Traversal → LaTeX

Steps:

1. Symbol detection: Locate bounding boxes of all symbols
2. Graph construction: Create nodes (symbols) and edges (spatial relationships)
3. Structure inference: Classify relationships (superscript, subscript, fraction, matrix)
4. Tree traversal: Convert graph to tree, traverse to generate LaTeX

Example:

Input Image: x²
Symbol Detection: [x], [2]
Graph: x --[superscript]--> 2
Tree Structure:
  superscript
  ├── base: x
  └── exponent: 2
LaTeX Generation: x^{2}

Advantages:

• Interpretable intermediate representation
• Can correct detection errors via context
• Handles nested structures naturally

Disadvantages:

• Requires separate symbol detection model
• Graph construction is non-trivial for complex equations
• Less end-to-end than Transformer approaches

7.4 Hybrid Approaches

pix2tex strategy:

1. Preprocessing: Neural network predicts optimal image resolution
2. Encoding: ResNet + ViT extract multi-scale features
3. Decoding: Transformer generates LaTeX with attention
4. Post-processing: Validate LaTeX syntax, fix common errors

Validation techniques:

• Syntax checking: Ensure balanced braces, valid commands
• Rendering verification: Render LaTeX and compare with input image
• Confidence thresholding: Flag low-confidence predictions for manual review

7.5 Specialized LaTeX Vocabularies

Design considerations:

• Vocabulary size: 500-1000 tokens (balance coverage vs. model size)
• Token granularity:
  • Character-level: \, f, r, a, c → \frac (more flexible, longer sequences)
  • Command-level: \frac as single token (shorter sequences, limited to known commands)
  • Hybrid: Common commands as tokens, rare symbols as characters

Example vocabulary (pix2tex):

SPECIAL_TOKENS = ['<BOS>', '<EOS>', '<PAD>', '<UNK>']
GREEK_LETTERS = ['\\alpha', '\\beta', '\\gamma', ...]
OPERATORS = ['\\int', '\\sum', '\\prod', '\\lim', ...]
DELIMITERS = ['\\left(', '\\right)', '\\{', '\\}', ...]
ENVIRONMENTS = ['\\begin{matrix}', '\\end{matrix}', ...]
SYMBOLS = ['\\infty', '\\partial', '\\nabla', ...]
ALPHANUMERIC = ['a', 'b', ..., 'z', 'A', 'B', ..., 'Z', '0', ..., '9']

7.6 Error Correction Techniques

Common LaTeX generation errors:

1. Unbalanced braces: x^2} instead of x^{2}
2. Missing delimiters: \frac12 instead of \frac{1}{2}
3. Wrong environment: \begin{matrix} without \end{matrix}
4. Incorrect symbol: \alpha instead of \Alpha

Correction strategies:

• Grammar-based post-processing: Rule-based syntax fixing
• Rendering feedback: Compare rendered output with input image, retry if dissimilar
• N-best rescoring: Generate multiple hypotheses, select best by rendering similarity
• Iterative refinement: Multi-pass generation (coarse → fine)

7.7 Real-time Generation Optimization

Techniques for low-latency inference:

• Model distillation: Compress large model into smaller student model
• Quantization: INT8 or FP16 precision (ONNX Runtime supports this)
• Pruning: Remove less important weights/attention heads
• Caching: Cache encoder outputs for interactive editing
• Speculative decoding: Predict multiple tokens in parallel

Benchmarks:

• pix2tex (25M params): ~50ms per formula on GPU, ~200ms on CPU
• PaddleOCR-VL (0.9B params): ~100-200ms per formula on GPU
• DeepSeek-OCR (3B MoE): ~300-500ms per page on GPU

---

8. Multi-language Support Considerations

8.1 Language Coverage in SOTA Models

Model	Languages	Script Support	Math Notation
PaddleOCR-VL	109	Latin, CJK, Arabic, Cyrillic	Universal LaTeX
dots.ocr	100+	Multilingual	Universal LaTeX
DeepSeek-OCR	Major languages	Primarily Latin, CJK	Universal LaTeX
pix2tex	Language-agnostic (symbols only)	N/A	Universal LaTeX

8.2 Mathematical Notation Variations

Regional differences:

• Decimal separators: . (US/UK) vs. , (Europe)
• Multiplication: × vs. · vs. juxtaposition
• Division: ÷ vs. / vs. fraction notation
• Function notation: sin(x) vs. sin x vs. \sin x

LaTeX standardization:

• ✅ LaTeX is universal across languages
• ✅ Mathematical symbols have consistent LaTeX representation
• ⚠️ Text within equations may require language detection
• ⚠️ Variable naming conventions vary (e.g., German uses x differently)

8.3 Language-Specific Challenges

8.3.1 Latin Scripts (English, Spanish, French, etc.)

• ✅ Well-supported by all models
• ✅ Largest training datasets available
• ✅ Single-byte character encoding (efficient)

8.3.2 CJK (Chinese, Japanese, Korean)

• ⚠️ Variable names may use CJK characters (e.g., 速度 for velocity)
• ⚠️ Requires larger vocabularies (thousands of characters)
• ⚠️ Text in equations common in educational materials
• ✅ PaddleOCR-VL and dots.ocr excel here

Example (Chinese math):

Input: 求极限 lim(x→∞) 1/x
LaTeX with CJK: \text{求极限} \lim_{x \to \infty} \frac{1}{x}

8.3.3 Right-to-Left Scripts (Arabic, Hebrew)

• ⚠️ Math notation typically left-to-right, but text is RTL
• ⚠️ Requires bidirectional text handling
• ⚠️ Fewer training datasets available
• ✅ dots.ocr and PaddleOCR-VL support this

8.3.4 Cyrillic (Russian, Ukrainian, etc.)

• ✅ Similar to Latin, well-supported
• ⚠️ Variable conventions differ (e.g., т for mass, с for speed)

8.4 Implementation Strategy for ruvector-scipix

Phase 1: Mathematical notation only (language-agnostic)

• Focus on pure LaTeX symbols and operators
• No text recognition within equations
• Achieves 90%+ of use cases (equations are mostly symbols)

Phase 2: English text support

• Add \text{...} recognition for labels and annotations
• Vocabulary: 26 letters + common words

Phase 3: Multi-language text (optional)

• Use language detection model (lightweight, ~10MB)
• Route text portions to language-specific sub-models
• PaddleOCR-VL pre-trained models cover 109 languages

Recommendation for v1.0:

• ✅ Start with math-only (universal LaTeX)
• ✅ Use PaddleOCR ONNX models (109 languages pre-trained)
• ✅ Defer text-in-equations to v2.0

---

9. Real-time Performance Requirements

9.1 Latency Targets by Use Case

Use Case	Target Latency	Acceptable Latency	User Experience Impact
Interactive editor (real-time)	<100ms	<300ms	Typing feedback, instant preview
Batch document processing	<1s per page	<5s per page	Background processing
Mobile app (tablet stylus)	<200ms	<500ms	Handwriting recognition responsiveness
Web API (sync)	<500ms	<2s	HTTP request timeout, user wait time
Web API (async)	<5s	<30s	Background job, email notification

9.2 Model Inference Benchmarks

Single formula/expression (GPU inference):

Model	Size	Latency (GPU)	Latency (CPU)	Throughput (batch=8, GPU)
pix2tex (LaTeX-OCR)	25M	50ms	200ms	160 formulas/sec
PaddleOCR-VL	0.9B	150ms	800ms	53 formulas/sec
DeepSeek-OCR	3B (MoE)	400ms	2000ms	20 formulas/sec
LightOnOCR	1B	100ms	500ms	80 formulas/sec

Full page (A4 document, GPU inference):

Model	Detection + Recognition	Single Model	Trade-off
Pipeline (PaddleOCR)	200ms + 500ms = 700ms	N/A	Higher quality, slower
End-to-end (DeepSeek)	N/A	400ms	Faster, lower quality on complex layouts

9.3 Hardware Acceleration

9.3.1 GPU (NVIDIA CUDA)

• Best for: Batch processing, server deployments
• Latency: 3-10× faster than CPU
• Throughput: 50-200 formulas/sec (batch size 8-32)
• ONNX Runtime: Full CUDA support via TensorRT execution provider

9.3.2 CPU (Intel/AMD)

• Best for: Edge devices, development, low-volume API
• Latency: Acceptable for <200ms models (pix2tex, LightOnOCR)
• Optimization: AVX512, OpenMP multithreading
• ONNX Runtime: Highly optimized CPU kernels

9.3.3 Mobile (ARM, Neural Engine)

• Best for: iOS/Android apps, tablets
• Quantization: INT8 reduces model size 4×, latency 2-3×
• CoreML (iOS): Native acceleration via Neural Engine
• NNAPI (Android): Hardware acceleration API
• ONNX Runtime: Mobile deployment supported

9.3.4 WebAssembly (WASM)

• Best for: Browser-based OCR, privacy-focused
• Performance: 2-5× slower than native CPU
• Model size: Critical (must be <50MB for web)
• ONNX Runtime: WASM backend available

9.4 Optimization Techniques for Rust + ONNX

9.4.1 Model Quantization

// Example: INT8 quantization reduces model size 4× and latency 2-3×
// ONNX Runtime supports dynamic quantization
let session = SessionBuilder::new()?
    .with_optimization_level(OptimizationLevel::Extended)?
    .with_graph_optimization_level(GraphOptimizationLevel::All)?
    .with_quantization(QuantizationType::Int8)?
    .build()?;

Impact:

• FP32 → FP16: 2× size reduction, 1.5-2× speedup (GPU)
• FP32 → INT8: 4× size reduction, 2-3× speedup (CPU/GPU)
• Accuracy loss: <1% for OCR models

9.4.2 Batch Processing

// Process multiple images in parallel
let batch_size = 8;
let images: Vec<ImageBuffer> = load_images(&paths);
let tensors = prepare_batch(&images, batch_size);
let outputs = session.run(tensors)?;  // ~3-5× throughput improvement

9.4.3 Model Caching and Warm-up

// Avoid cold start latency
lazy_static! {
    static ref MODEL: Session = {
        let session = SessionBuilder::new().build().unwrap();
        // Warm-up inference
        let dummy_input = create_dummy_input();
        session.run(dummy_input).ok();
        session
    };
}

Cold start: 100-500ms (load model from disk) Warm inference: 50-200ms (model in memory)

9.4.4 Preprocessing Pipeline Optimization

// Parallelize image preprocessing
use rayon::prelude::*;

let preprocessed: Vec<Tensor> = images
    .par_iter()  // Parallel iterator
    .map(|img| {
        resize(img, 384, 384)
            .normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
            .to_tensor()
    })
    .collect();

Impact: 20-50% reduction in total latency for batch processing

9.4.5 Asynchronous Inference

// Non-blocking inference for web servers
use tokio::task;

async fn infer_async(image: ImageBuffer) -> Result<String> {
    task::spawn_blocking(move || {
        let tensor = preprocess(&image);
        let output = MODEL.run(tensor)?;
        postprocess(output)
    }).await?
}

9.5 Scalability Considerations

9.5.1 Vertical Scaling (Single Server)

• Multi-threading: Process multiple requests in parallel
• GPU batching: Accumulate requests, infer in batches
• Memory management: Load models once, share across threads
• Expected throughput: 50-200 formulas/sec (GPU), 10-30 formulas/sec (CPU)

9.5.2 Horizontal Scaling (Distributed)

• Load balancer: Distribute requests across multiple inference servers
• Stateless inference: Each server is independent
• Auto-scaling: Add/remove servers based on load
• Expected throughput: Linear scaling (2× servers = 2× throughput)

9.5.3 Edge Deployment

• Model distillation: Use smaller models (pix2tex 25M, not DeepSeek 3B)
• Quantization: INT8 for mobile devices
• Latency priority: Accept slightly lower accuracy for <200ms latency

9.6 Recommendations for ruvector-scipix

Performance targets:

• ✅ Real-time mode: <200ms (use pix2tex 25M or LightOnOCR 1B)
• ✅ Batch mode: <1s per formula (use PaddleOCR-VL 0.9B or DeepSeek 3B)

Optimization strategy:

1. Start with CPU inference (easier deployment, sufficient for v1.0)
2. Implement ONNX quantization (INT8 for 2-3× speedup)
3. Add GPU support (optional, for high-volume users)
4. Benchmark on target hardware (measure actual latency, adjust model choice)

Rust + ONNX advantages:

• ✅ Memory safety and zero-cost abstractions
• ✅ Excellent ONNX Runtime bindings (ort crate by pykeio)
• ✅ Native performance (no Python overhead)
• ✅ Easy deployment (single binary, no dependencies)

---

10. Recommendations for ruvector-scipix Implementation

10.1 Model Selection

Primary Recommendation: PaddleOCR-VL with ONNX Runtime

Rationale:

1. ✅ Excellent ONNX support: Native PaddlePaddle → ONNX export
2. ✅ Rust ecosystem: oar-ocr and paddle-ocr-rs crates available
3. ✅ Optimal size-accuracy trade-off: 0.9B params, competitive with 70B VLMs
4. ✅ 109 languages pre-trained: Future-proof for internationalization
5. ✅ Fast inference: 2.67× faster than dots.ocr, acceptable latency
6. ✅ Production-ready: Comprehensive tooling, active development
7. ✅ Open-source: Apache 2.0 license, permissive

Implementation path:

// Use oar-ocr crate (https://github.com/GreatV/oar-ocr)
use oar_ocr::{OCREngine, OCRModel};

let engine = OCREngine::new(
    OCRModel::PaddleOCRVL09B,
    DeviceType::CPU,  // or GPU
)?;

let image = load_image("formula.png")?;
let latex = engine.recognize(&image)?;
println!("LaTeX: {}", latex);

Alternative 1: pix2tex (LaTeX-OCR) via ONNX

Rationale:

• ✅ Smallest model: 25M params, fast inference (50ms GPU, 200ms CPU)
• ✅ Purpose-built: Specifically designed for LaTeX OCR
• ✅ Good accuracy: Trained on Im2latex-100k, proven performance
• ⚠️ Manual ONNX export: Not officially available, requires conversion
• ⚠️ Limited language support: Math symbols only (acceptable for v1.0)

Implementation path:

1. Export PyTorch model to ONNX using torch.onnx.export
2. Load in Rust using ort crate
3. Implement preprocessing (ResNet input format)
4. Implement postprocessing (beam search decoder)

Alternative 2: Custom ViT + Transformer Model

Rationale:

• ✅ Full control: Tailor architecture to specific use cases
• ✅ ONNX-first design: Build with ONNX export in mind
• ❌ Time-intensive: Requires training from scratch or fine-tuning
• ❌ Data requirements: Need Im2latex-100k + MathWriting for best results
• ⚠️ Defer to v2.0: Focus on proven models for v1.0

10.2 Development Roadmap

Phase 1: MVP (v0.1.0) - Printed Math Only

Timeline: 2-4 weeks

Features:

• Single formula OCR (image → LaTeX)
• PaddleOCR-VL or pix2tex model
• CPU inference only
• Basic preprocessing (resize, normalize)
• LaTeX output with confidence scores

Success criteria:

• 90%+ accuracy on Im2latex-100k test set
• <500ms latency per formula (CPU)
• ONNX model loaded in Rust

Dependencies:

• ort crate for ONNX Runtime
• image crate for preprocessing
• oar-ocr or custom ONNX inference

Phase 2: Production Ready (v1.0.0) - Scipix Clone

Timeline: 4-8 weeks

Features:

• Batch document processing (PDF/image upload)
• Multi-formula detection (layout analysis)
• GPU acceleration support
• Web API (REST or gRPC)
• LaTeX rendering for verification
• Confidence thresholding and error handling

Success criteria:

• 95%+ accuracy on Im2latex-100k
• <200ms latency per formula (GPU)
• Handle multi-page documents
• Production-grade error handling

Additional components:

• Formula detection model (YOLO or faster R-CNN in ONNX)
• LaTeX renderer (integration with KaTeX or MathJax)
• Database for result caching

Phase 3: Advanced Features (v2.0.0)

Timeline: 8-16 weeks

Features:

• Handwritten math recognition (MathWriting dataset)
• Multi-language text in equations
• Interactive editor with live preview
• User correction feedback loop
• Model fine-tuning pipeline

Success criteria:

• 85%+ accuracy on MathWriting
• <100ms latency (real-time mode)
• Support 10+ languages

10.3 Technical Architecture

┌─────────────────────────────────────────────────────────────┐
│                     ruvector-scipix                        │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  ┌───────────────┐  ┌───────────────┐  ┌───────────────┐  │
│  │  Web API      │  │  CLI Tool     │  │  Library      │  │
│  │  (REST/gRPC)  │  │  (CLI args)   │  │  (Rust crate) │  │
│  └───────┬───────┘  └───────┬───────┘  └───────┬───────┘  │
│          │                  │                  │          │
│          └──────────────────┴──────────────────┘          │
│                             │                             │
│                  ┌──────────▼──────────┐                  │
│                  │  Core OCR Engine    │                  │
│                  │  - Model loading    │                  │
│                  │  - Preprocessing    │                  │
│                  │  - Inference        │                  │
│                  │  - Postprocessing   │                  │
│                  └──────────┬──────────┘                  │
│                             │                             │
│          ┌──────────────────┼──────────────────┐          │
│          │                  │                  │          │
│  ┌───────▼───────┐  ┌──────▼──────┐  ┌───────▼───────┐  │
│  │ Detection     │  │ Recognition │  │ Verification  │  │
│  │ (formula bbox)│  │ (LaTeX gen) │  │ (rendering)   │  │
│  └───────────────┘  └──────────────┘  └───────────────┘  │
│                                                             │
├─────────────────────────────────────────────────────────────┤
│                      ONNX Runtime (ort crate)               │
│  - CPU/GPU inference                                        │
│  - Quantization (INT8/FP16)                                 │
│  - Multi-threading                                          │
├─────────────────────────────────────────────────────────────┤
│                    ONNX Models                              │
│  - PaddleOCR-VL-0.9B (recognition)                          │
│  - YOLO/Faster R-CNN (detection, optional)                  │
├─────────────────────────────────────────────────────────────┤
│                     System Layer                            │
│  - Image I/O (image crate)                                  │
│  - PDF parsing (pdf crate)                                  │
│  - GPU drivers (CUDA, Metal)                                │
└─────────────────────────────────────────────────────────────┘

10.4 Rust Crate Structure

ruvector-scipix/
├── src/
│   ├── lib.rs                 # Public API
│   ├── engine.rs              # Core OCR engine
│   ├── models/
│   │   ├── mod.rs
│   │   ├── paddleocr.rs       # PaddleOCR-VL integration
│   │   ├── pix2tex.rs         # pix2tex integration (optional)
│   │   └── detection.rs       # Formula detection model
│   ├── preprocessing/
│   │   ├── mod.rs
│   │   ├── resize.rs          # Image resizing
│   │   ├── normalize.rs       # Normalization
│   │   └── augmentation.rs    # Data augmentation (training)
│   ├── postprocessing/
│   │   ├── mod.rs
│   │   ├── beam_search.rs     # Beam search decoder
│   │   ├── latex_validator.rs # LaTeX syntax validation
│   │   └── confidence.rs      # Confidence scoring
│   ├── utils/
│   │   ├── mod.rs
│   │   ├── image_io.rs        # Image loading/saving
│   │   └── latex_render.rs    # LaTeX rendering for verification
│   └── cli.rs                 # CLI tool implementation
├── examples/
│   ├── simple_ocr.rs          # Basic usage example
│   ├── batch_processing.rs    # Batch document processing
│   └── web_api.rs             # REST API server
├── models/                    # ONNX model files (.onnx)
│   ├── paddleocr_vl_09b.onnx
│   └── detection_yolo.onnx    # Optional formula detection
├── tests/
│   ├── integration_tests.rs   # End-to-end tests
│   └── benchmark.rs           # Performance benchmarks
└── Cargo.toml

10.5 Key Dependencies

[dependencies]
# ONNX Runtime for model inference
ort = "2.0"  # https://github.com/pykeio/ort

# Image processing
image = "0.25"
imageproc = "0.25"

# Optional: Use oar-ocr for PaddleOCR integration
oar-ocr = "0.2"  # https://github.com/GreatV/oar-ocr

# Async runtime (for web API)
tokio = { version = "1.0", features = ["full"] }

# Web framework (optional)
axum = "0.7"  # or actix-web

# Parallel processing
rayon = "1.10"

# CLI argument parsing
clap = { version = "4.5", features = ["derive"] }

# Serialization
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"

# Error handling
anyhow = "1.0"
thiserror = "1.0"

# Logging
tracing = "0.1"
tracing-subscriber = "0.3"

10.6 Model Deployment Strategy

Option A: Bundle ONNX models with binary

# Cargo.toml
[package.metadata.models]
include = ["models/*.onnx"]

Pros:

• ✅ Single-binary deployment
• ✅ No external dependencies

Cons:

• ❌ Large binary size (0.9B model = ~2GB)
• ❌ Difficult to update models

Option B: Download models on first run

// Lazy model loading
static MODEL: OnceCell<Session> = OnceCell::new();

fn get_model() -> &Session {
    MODEL.get_or_init(|| {
        let model_path = download_model_if_missing(
            "https://huggingface.co/PaddlePaddle/PaddleOCR-VL/resolve/main/model.onnx",
            "~/.ruvector/models/paddleocr_vl.onnx"
        ).expect("Failed to download model");

        Session::builder()
            .unwrap()
            .with_model_from_file(model_path)
            .unwrap()
    })
}

Pros:

• ✅ Small binary size
• ✅ Easy to update models

Cons:

• ⚠️ Requires internet connection on first run
• ⚠️ Startup latency on first run

Recommendation: Option B (download on first run) for flexibility

10.7 Testing Strategy

Unit Tests

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_preprocessing() {
        let img = load_test_image("tests/data/formula_001.png");
        let tensor = preprocess(&img);
        assert_eq!(tensor.shape(), &[1, 3, 384, 384]);
    }

    #[test]
    fn test_latex_validation() {
        assert!(is_valid_latex(r"\frac{1}{2}"));
        assert!(!is_valid_latex(r"\frac{1}{2"));  // Missing closing brace
    }
}

Integration Tests

#[tokio::test]
async fn test_end_to_end_ocr() {
    let engine = OCREngine::new(OCRModel::PaddleOCRVL09B, DeviceType::CPU).unwrap();

    let test_cases = vec![
        ("tests/data/formula_001.png", r"\frac{1}{2}"),
        ("tests/data/formula_002.png", r"\int_0^\infty e^{-x^2} dx"),
        ("tests/data/formula_003.png", r"\sum_{i=1}^n i = \frac{n(n+1)}{2}"),
    ];

    for (img_path, expected_latex) in test_cases {
        let img = load_image(img_path).unwrap();
        let result = engine.recognize(&img).await.unwrap();
        assert_eq!(result.latex, expected_latex);
        assert!(result.confidence > 0.9);
    }
}

Benchmark Tests

use criterion::{black_box, criterion_group, criterion_main, Criterion};

fn bench_inference(c: &mut Criterion) {
    let engine = OCREngine::new(OCRModel::PaddleOCRVL09B, DeviceType::CPU).unwrap();
    let img = load_image("tests/data/formula_001.png").unwrap();

    c.bench_function("ocr_inference", |b| {
        b.iter(|| {
            engine.recognize(black_box(&img)).unwrap()
        })
    });
}

criterion_group!(benches, bench_inference);
criterion_main!(benches);

Target benchmarks:

• Preprocessing: <10ms
• Inference (CPU): <200ms
• Postprocessing: <20ms
• Total latency: <250ms

10.8 Performance Optimization Checklist

• Use ONNX quantization (INT8) for 2-3× CPU speedup
• Implement batch inference for throughput
• Parallelize preprocessing with Rayon
• Cache loaded models in memory
• Pre-warm models with dummy inference
• GPU acceleration via CUDA/TensorRT execution provider
• Model distillation (compress 0.9B → 100M for edge devices)
• Profile hot paths with perf or flamegraph
• Async inference for non-blocking web API

10.9 Deployment Options

1. Standalone CLI Tool

cargo build --release
./target/release/ruvector-scipix formula.png --output latex
# Output: \frac{1}{2}

2. REST API Server

cargo run --bin api-server --port 8080
# POST /ocr with image → JSON response with LaTeX

3. Rust Library (crate)

use ruvector_scipix::{OCREngine, OCRModel, DeviceType};

#[tokio::main]
async fn main() {
    let engine = OCREngine::new(OCRModel::PaddleOCRVL09B, DeviceType::GPU).unwrap();
    let image = load_image("formula.png").unwrap();
    let result = engine.recognize(&image).await.unwrap();
    println!("LaTeX: {}", result.latex);
    println!("Confidence: {:.2}%", result.confidence * 100.0);
}

4. WebAssembly (Browser)

cargo build --target wasm32-unknown-unknown --release
wasm-pack build --target web
# Use in browser with ONNX Runtime WASM backend

10.10 License and Open Source Considerations

Model licenses:

• PaddleOCR-VL: Apache 2.0 ✅ Permissive
• pix2tex: MIT ✅ Permissive
• DeepSeek-OCR: Apache 2.0 ✅ Permissive
• dots.ocr: Check repository (likely MIT or Apache)

Recommended license for ruvector-scipix:

• MIT or Apache 2.0 for maximum adoption
• Compatible with all recommended models

10.11 Risk Assessment and Mitigation

Risk	Probability	Impact	Mitigation
ONNX export compatibility issues	Medium	High	Start with PaddleOCR (proven ONNX support)
Accuracy below 90% on Im2latex-100k	Low	Medium	Use pre-trained models, validate before release
Latency >500ms on CPU	Medium	Medium	Implement quantization, consider GPU
Model size too large (>5GB binary)	High	Low	Download models on first run (not bundled)
Handwritten accuracy <70%	High	Low	Defer to v2.0, focus on printed math for v1.0
Limited language support	Low	Low	PaddleOCR-VL covers 109 languages out-of-box

---

Conclusion

The state-of-the-art in AI-driven mathematical OCR has advanced dramatically in 2025, with Vision Language Models achieving 98%+ accuracy on printed text and 80-95% on handwritten expressions. For the ruvector-scipix project:

Key Takeaways:

1. Use PaddleOCR-VL with ONNX Runtime for optimal Rust compatibility
2. Target 95%+ accuracy on printed math (achievable with current models)
3. Prioritize latency optimization (<200ms for real-time use cases)
4. Start with printed math only, defer handwritten to v2.0
5. Leverage Rust's performance for efficient ONNX inference

Immediate Next Steps:

1. Integrate oar-ocr or ort crate for ONNX Runtime
2. Download PaddleOCR-VL ONNX model from Hugging Face
3. Implement basic preprocessing pipeline (resize, normalize)
4. Validate accuracy on Im2latex-100k test set samples
5. Benchmark latency on target hardware (CPU/GPU)

Success Criteria for v1.0:

• ✅ 95%+ accuracy on Im2latex-100k
• ✅ <200ms latency per formula (GPU) or <500ms (CPU)
• ✅ Production-grade error handling and logging
• ✅ Comprehensive test coverage (unit, integration, benchmarks)

---

Sources

Web Search References

1. DeepSeek-OCR Architecture Explained
2. deepseek-ai/DeepSeek-OCR on Hugging Face
3. DeepSeek-OCR Hands-On Guide - DataCamp
4. GitHub - deepseek-ai/DeepSeek-OCR
5. PaddleOCR 3.0 Technical Report
6. GitHub - rednote-hilab/dots.ocr
7. dots.ocr on Hugging Face
8. PaddleOCR-VL: Best OCR AI Model - Medium
9. Complete Guide to Open-Source OCR Models for 2025
10. GitHub - lukas-blecher/LaTeX-OCR (pix2tex)
11. pix2tex Documentation
12. breezedeus/pix2text-mfr on Hugging Face
13. im2latex-100k Benchmark on Papers With Code
14. MathWriting Dataset Paper (ACM SIGKDD 2025)
15. MathWriting Dataset on arXiv
16. OCRBench v2 Paper
17. GitHub - GreatV/oar-ocr (Rust OCR Library)
18. oar-ocr on crates.io
19. GitHub - pykeio/ort (ONNX Runtime for Rust)
20. GitHub - mg-chao/paddle-ocr-rs

---

Document prepared by: AI OCR Research Specialist Last updated: November 28, 2025 Version: 1.0