depyler
A Python-to-Rust transpiler with semantic verification and memory safety analysis.
Depyler translates annotated Python code into idiomatic Rust, preserving program semantics while providing compile-time safety guarantees. Part of the PAIML Stack.
- Features
- Installation
- Quick Start
- Usage
- Supported Python Features
- Stdlib Module Support
- Architecture
- Documentation
- Quality Metrics
- Contributing
- License
All three external corpus targets now met:
| Corpus | Compile Rate | Target |
|---|---|---|
| Tier 1 (stdlib) | 92.7% (38/41) | 80% ✅ |
| Tier 2 (typed-cli) | 62.5% (10/16) | 60% ✅ |
| Tier 5 (algorithms) | 47.5% (48/101) | 40% ✅ |
| Internal examples | 80% (256/320) | 80% ✅ |
- Type-Directed Transpilation — Uses Python type annotations to generate appropriate Rust types
- Memory Safety Analysis — Infers ownership and borrowing patterns automatically
- Semantic Verification — Property-based testing to verify behavioral equivalence
- Single-Command Compilation — Compile Python to native binaries with
depyler compile - 27 Stdlib Modules — Production-ready support for common Python standard library modules
- 80%+ Single-Shot Compile Rate — Most Python files compile on first transpilation attempt
cargo install depyler
- Rust 1.83.0 or later
- Python 3.8+ (for test validation)
The fastest way to use Depyler:
# Compile Python to a standalone binary depyler compile script.py # Run the compiled binary ./script
# Transpile a Python file to Rust depyler transpile example.py # Transpile with semantic verification depyler transpile example.py --verify
Input (fibonacci.py):
def fibonacci(n: int) -> int: if n <= 1: return n return fibonacci(n - 1) + fibonacci(n - 2)
Output (fibonacci.rs):
fn fibonacci(n: i32) -> i32 { if n <= 1 { return n; } fibonacci(n - 1) + fibonacci(n - 2) }
# Compile with custom output name depyler compile script.py -o my_app # Debug build (faster compilation) depyler compile script.py --profile debug # Release build (optimized, default) depyler compile script.py --profile release
# Show transpilation trace depyler transpile example.py --trace # Explain transformation decisions depyler transpile example.py --explain # Analyze migration complexity depyler analyze example.py
use depyler::{transpile_file, TranspileOptions}; fn main() -> Result<(), Box<dyn std::error::Error>> { let options = TranspileOptions::default() .with_verification(true); let rust_code = transpile_file("example.py", options)?; println!("{}", rust_code); Ok(()) }
| Feature | Status |
|---|---|
| Functions with type annotations | Supported |
| Basic types (int, float, str, bool) | Supported |
| Collections (List, Dict, Tuple, Set) | Supported |
| Control flow (if, while, for, match) | Supported |
| Comprehensions (list, dict, set) | Supported |
| Generator expressions | Supported |
| Exception handling (→ Result<T, E>) | Supported |
| Classes and methods | Supported |
| Async/await | Supported |
| Context managers | Supported |
Not Supported: Dynamic features (eval, exec), runtime reflection, multiple inheritance, monkey patching.
27 modules validated with 151 tests passing (100% coverage).
| Category | Modules |
|---|---|
| Serialization | json, struct, base64, csv |
| Date/Time | datetime, calendar, time |
| Cryptography | hashlib, secrets |
| Text | textwrap, re, string |
| Math | math, decimal, fractions, statistics |
| File System | os, pathlib, io |
| Data Structures | collections, copy, memoryview, array |
| Functional | itertools, functools |
| Random | random |
| System | sys |
See validation report for details.
Python AST → HIR → Type Inference → Rust AST → Code Generation
| Component | Description |
|---|---|
| Parser | RustPython AST parser |
| HIR | High-level intermediate representation |
| Type System | Conservative type inference with annotation support |
| Verification | Property-based testing for semantic equivalence |
| Codegen | Rust code generation via syn/quote |
- API Documentation
- MCP Quickstart
- Agent Mode Guide
- Developer Prompts
- Changelog
- TDD Book
- 🤖 Coursera Hugging Face AI Development Specialization - Build Production AI systems with Hugging Face in Pure Rust
| Metric | Value |
|---|---|
| Single-Shot Compile Rate | 80% (256/320 examples) |
| Line Coverage | 87.85% |
| Function Coverage | 92.85% |
| Total Tests | 14,000+ |
| Mutation Kill Rate | 75%+ |
Run coverage locally:
cargo llvm-cov nextest --workspace --lib --summary-only
Contributions welcome! Please follow the quality standards:
- Write tests first (TDD)
- Maintain 80%+ coverage for new code
- Pass all clippy checks:
cargo clippy -- -D warnings - Format code:
cargo fmt
See CONTRIBUTING.md for details.
Licensed under MIT License. See LICENSE for details.