https://github.com/paiml/depyler
Compiles Python to Rust, helping transition off of Python to Energy Efficient and Safe Rust Code
https://github.com/paiml/depyler
conversion mcp port python pythontorust rust
Last synced: 12 days ago
JSON representation
Compiles Python to Rust, helping transition off of Python to Energy Efficient and Safe Rust Code
- Host: GitHub
- URL: https://github.com/paiml/depyler
- Owner: paiml
- License: mit
- Created: 2025-06-04T17:13:41.000Z (10 months ago)
- Default Branch: main
- Last Pushed: 2026-03-09T05:06:37.000Z (about 1 month ago)
- Last Synced: 2026-03-09T09:49:21.632Z (about 1 month ago)
- Topics: conversion, mcp, port, python, pythontorust, rust
- Language: Rust
- Homepage: https://paiml.github.io/depyler/
- Size: 55.8 MB
- Stars: 336
- Watchers: 3
- Forks: 13
- Open Issues: 125
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- Contributing: CONTRIBUTING.md
- License: LICENSE
- Citation: CITATION.cff
- Security: SECURITY.md
- Roadmap: ROADMAP.md
Awesome Lists containing this project
- awesome-mcp - paiml/depyler - Depyler is a Python-to-Rust transpiler with semantic verification and memory safety analysis, available as an MCP server to assist AI tools in migrating Python codebases to safe and efficient Rust code. (MCP Servers / Software Development)
README
# depyler
**A Python-to-Rust transpiler with semantic verification and memory safety analysis.**
[](https://crates.io/crates/depyler)
[](https://docs.rs/depyler)
[](https://github.com/paiml/depyler/actions/workflows/ci.yml)
[](https://opensource.org/licenses/MIT)
---
Depyler translates annotated Python code into idiomatic Rust, preserving program semantics while providing compile-time safety guarantees. Part of the [PAIML Stack](https://github.com/paiml).
## Table of Contents
- [Features](#features)
- [Installation](#installation)
- [Quick Start](#quick-start)
- [Usage](#usage)
- [Supported Python Features](#supported-python-features)
- [Stdlib Module Support](#stdlib-module-support)
- [Architecture](#architecture)
- [Documentation](#documentation)
- [Quality Metrics](#quality-metrics)
- [Contributing](#contributing)
- [License](#license)
## v3.25.0 Milestone: Multi-Corpus Convergence
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% ✅ |
## Features
- **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
## Installation
```bash
cargo install depyler
```
### Requirements
- Rust 1.83.0 or later
- Python 3.8+ (for test validation)
## Quick Start
### Compile to Binary
The fastest way to use Depyler:
```bash
# Compile Python to a standalone binary
depyler compile script.py
# Run the compiled binary
./script
```
### Transpile to Rust
```bash
# Transpile a Python file to Rust
depyler transpile example.py
# Transpile with semantic verification
depyler transpile example.py --verify
```
### Example
**Input** (`fibonacci.py`):
```python
def fibonacci(n: int) -> int:
if n <= 1:
return n
return fibonacci(n - 1) + fibonacci(n - 2)
```
**Output** (`fibonacci.rs`):
```rust
fn fibonacci(n: i32) -> i32 {
if n <= 1 {
return n;
}
fibonacci(n - 1) + fibonacci(n - 2)
}
```
## Usage
### Compilation Options
```bash
# 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
```
### Transpilation Options
```bash
# Show transpilation trace
depyler transpile example.py --trace
# Explain transformation decisions
depyler transpile example.py --explain
# Analyze migration complexity
depyler analyze example.py
```
### Library Usage
```rust
use depyler::{transpile_file, TranspileOptions};
fn main() -> Result<(), Box> {
let options = TranspileOptions::default()
.with_verification(true);
let rust_code = transpile_file("example.py", options)?;
println!("{}", rust_code);
Ok(())
}
```
## Supported Python Features
| 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) | Supported |
| Classes and methods | Supported |
| Async/await | Supported |
| Context managers | Supported |
**Not Supported:** Dynamic features (eval, exec), runtime reflection, multiple inheritance, monkey patching.
## Stdlib Module Support
**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](tdd-book/VALIDATION-FINAL-2025-10-26.md) for details.
## Architecture
```
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 |
## Documentation
- [API Documentation](https://docs.rs/depyler)
- [MCP Quickstart](docs/MCP_QUICKSTART.md)
- [Agent Mode Guide](AGENT.md)
- [Developer Prompts](docs/prompts/)
- [Changelog](CHANGELOG.md)
- [TDD Book](tdd-book/)
- 🤖 [Coursera Hugging Face AI Development Specialization](https://www.coursera.org/specializations/hugging-face-ai-development) - Build Production AI systems with Hugging Face in Pure Rust
## Quality Metrics
| 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:
```bash
cargo llvm-cov nextest --workspace --lib --summary-only
```
## Contributing
Contributions welcome! Please follow the quality standards:
1. Write tests first (TDD)
2. Maintain 80%+ coverage for new code
3. Pass all clippy checks: `cargo clippy -- -D warnings`
4. Format code: `cargo fmt`
See [CONTRIBUTING.md](CONTRIBUTING.md) for details.
## MSRV
Minimum Supported Rust Version: **1.83**
## License
Licensed under MIT License. See [LICENSE](LICENSE) for details.