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.

Table of Contents

• What's New in v4.1.1
• Features
• Installation
• Quick Start
• Usage
• Supported Python Features
• Stdlib Module Support
• Architecture
• Documentation
• Quality Metrics
• Contributing
• License

What's New in v4.1.1

• str(dict.get(key, default)) fix: No longer generates spurious .unwrap() calls
• 25+ Python module mappings: tempfile, datetime, os, shutil, glob, and more
• E0433 import resolution: Improved handling of unresolved imports
• [profile.test] opt-level=1: Faster test execution

Multi-Corpus Convergence (v3.25.0+)

All three external corpus targets met:

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

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:

# Compile Python to a standalone binary
depyler compile script.py

# Run the compiled binary
./script

Transpile to Rust

# Transpile a Python file to Rust
depyler transpile example.py

# Transpile with semantic verification
depyler transpile example.py --verify

Example

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)
}

Usage

Compilation Options

# 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

# 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

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(())
}

Supported Python Features

Not Supported: Dynamic features (eval, exec), runtime reflection, multiple inheritance, monkey patching.

Stdlib Module Support

27 modules validated with 151 tests passing (100% coverage).

See validation report for details.

Architecture

Python AST → HIR → Type Inference → Rust AST → Code Generation

Documentation

• 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

Quality Metrics

Run coverage locally:

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 for details.

MSRV

Minimum Supported Rust Version: 1.83

Cookbook

See depyler-cookbook for examples and recipes.

License

Licensed under MIT License. See LICENSE for details.