Problem Addressed

RustPython

Overview

RustPython is a Python 3 interpreter written entirely in Rust. It provides CPython 3.14.0+ compatibility and can run as a standalone interpreter, be compiled to WebAssembly for browser execution, or be embedded into Rust applications for scripting. The project shares its parser with Ruff (the fast Python linter) via the ruff_python_parser crate, and includes an experimental JIT compiler for native code generation.

Problem Addressed

Key Statistics

Key Features

Core Interpreter

• CPython 3.14.0+ Compatibility: Targets modern Python 3 language features
• Stack-based VM: Executes compiled bytecode using stack machine architecture
• Standard Library: Partial stdlib implementation in Rust with CPython Lib/ fallback
• pip Support: Full pip installation and package management with SSL features
• venv Support: Virtual environment creation for isolated package management
• Threading: Optional multi-threading support via threading feature flag

WebAssembly Support

• WASI Compilation: Build standalone WASM binary for any WASI-compatible runtime
• Browser Execution: Run Python directly in web browsers via wasm-bindgen
• Freeze Stdlib: Embed standard library in WASM binary for self-contained deployment
• JS Interop: Bidirectional JavaScript/Python data exchange in browser context
• Runtime Compatibility: Works with wasmer, wasmtime, and browser WASM engines

Embedding in Rust

• Library Crate: Use as dependency for adding Python scripting to Rust applications
• PyModule/PyClass Macros: Ergonomic derive macros for exposing Rust types to Python
• Safe FFI Alternative: No unsafe C FFI required, pure Rust integration
• Configurable Features: Fine-grained control over included functionality

JIT Compiler (Experimental)

• Native Code Generation: Compile Python functions to machine code
• Opt-in Compilation: Call __jit__() on functions to enable JIT
• Cranelift Backend: Uses Cranelift for code generation
• Requirements: Requires autoconf, automake, libtool, clang at build time

Parser (via ruff_python_parser)

• Shared with Ruff: Uses the same parser as Ruff Python linter
• Fast Parsing: Rust-native lexer and parser for Python source
• AST Generation: Produces standard Python AST for compilation

Technical Architecture

Component Stack

Python Source Code
       |
   ruff_python_parser (Lexer + Parser)
       |
   Abstract Syntax Tree (AST)
       |
   rustpython-compiler (AST to Bytecode)
       |
   Bytecode
       |
   rustpython-vm (Stack-based VM execution)
       |
   Output / Side Effects

Crate Structure

VM Architecture

• Stack Machine: Operations push/pop values from evaluation stack
• Frame-based Execution: Each function call creates new frame with local namespace
• Object Model: Python objects implemented as Rust structs with trait implementations
• GC: Reference counting with cycle detection (via Rust's ownership where possible)

Installation and Usage

Build from Source

# Clone repository
git clone https://github.com/RustPython/RustPython
cd RustPython

# Windows: enable symlinks for Lib/
git config core.symlinks true

# Build and run demo
cargo run --release demo_closures.py

# Interactive REPL
cargo run --release

Install via Cargo

# Install from Git
cargo install --git https://github.com/RustPython/RustPython rustpython

# Run interpreter
rustpython

Install via Conda

conda install rustpython -c conda-forge

Feature Flags

# Default features
cargo run --release  # threading, stdlib, stdio, importlib, ssl-rustls

# Enable JIT compiler
cargo run --release --features jit

# Enable SQLite support
cargo run --release --features sqlite

# Build with OpenSSL instead of rustls
cargo run --release --no-default-features --features "threading stdlib stdio importlib ssl-openssl"

pip Installation

# Install with SSL support first
cargo install --git https://github.com/RustPython/RustPython

# Bootstrap pip
rustpython --install-pip

# Use pip normally
rustpython -m pip install requests

Virtual Environment

# Create venv
rustpython -m venv myenv

# Activate (Linux/macOS)
source myenv/bin/activate

# Now 'python' points to rustpython
python --version

WebAssembly Build

# Add WASI target
rustup target add wasm32-wasip1

# Build WASM binary with frozen stdlib
cargo build --target wasm32-wasip1 --no-default-features \
    --features freeze-stdlib,stdlib --release

# Run with wasmer
wasmer run --dir . -- target/wasm32-wasip1/release/rustpython.wasm script.py

Embedding in Rust

use rustpython_vm as vm;

fn main() -> vm::PyResult<()> {
    vm::Interpreter::without_stdlib(Default::default()).enter(|vm| {
        let scope = vm.new_scope_with_builtins();
        let code = vm.compile(
            r#"print("Hello from RustPython!")"#,
            vm::compile::Mode::Exec,
            "<embedded>".to_owned(),
        )?;
        vm.run_code_obj(code, scope)?;
        Ok(())
    })
}

JIT Compilation

def compute(n):
    total = 0
    for i in range(n):
        total += i
    return total

# Enable JIT for this function
compute.__jit__()

# Subsequent calls execute native code
result = compute(1000000)

Notable Projects Using RustPython

Relevance to Claude Code Development

Direct Applications

1. Browser-based Python Execution: RustPython's WASM support enables running Python code in browser environments, potentially useful for web-based development tools or sandboxed code execution.

2. Embedded Scripting for Tools: Rust-based Claude Code tools could embed RustPython for user-extensible scripting without CPython dependency.

3. Sandboxed Code Execution: WASM isolation provides security boundaries for executing untrusted Python code in agent workflows.

4. Lightweight Python Runtime: For scenarios where full CPython is too heavy, RustPython with frozen stdlib provides smaller deployment footprint.

5. Cross-Platform Consistency: Single WASM binary ensures identical Python behavior across all platforms.

Patterns Worth Adopting

1. Feature Flag Architecture: RustPython's fine-grained feature flags enable precise control over included functionality - applicable to Claude Code skill configuration.

2. Parser Reuse (ruff_python_parser): Sharing parser implementation between RustPython and Ruff demonstrates effective code reuse across projects.

3. Freeze-stdlib Pattern: Embedding standard library in binary for self-contained deployment - applicable to Claude Code plugin distribution.

4. Opt-in JIT: Manual JIT activation via __jit__() provides user control over optimization - similar to opt-in performance features in skills.

5. Derive Macros for Extension: PyModule/PyClass macros demonstrate ergonomic Rust extension patterns.

Integration Opportunities

1. MCP Server in WASM: Deploy MCP servers as WASM modules using RustPython for portable, sandboxed execution.

2. Python Code Analysis: Use ruff_python_parser (shared with RustPython) for fast Python AST analysis in code review skills.

3. Browser-based Code Execution: Run Python examples in documentation or tutorials without server-side execution.

4. Embedded Scripting Layer: Add Python scripting to Rust-based Claude Code tools without CPython FFI complexity.

5. Security Sandbox: Use WASM isolation for running user-provided Python code safely in agentic workflows.

Comparison with Other Python Runtimes

Limitations to Consider

1. Not Production-Ready: Project documentation explicitly states RustPython is in development and not fully production-ready.

2. Performance Gap: Pure interpretation without mature JIT is slower than CPython for compute-intensive workloads.

3. Incomplete stdlib: Not all standard library modules are implemented; some require CPython fallback.

4. C Extension Incompatibility: Cannot run CPython C extensions (numpy, pandas, etc.) - pure Python packages only.

5. JIT Maturity: JIT compiler is experimental with limited optimization coverage.

References

Research Method: Information gathered from official GitHub repository README, architecture documentation, WASM documentation, Cargo.toml workspace configuration, and GitHub API for statistics. All statistics verified via direct API calls on 2026-02-05.

Freshness Tracking

Review Triggers:

• Major version release (0.5.0, 1.0.0)
• JIT compiler exits experimental status
• Significant CPython compatibility milestone (e.g., 3.15 support)
• GitHub stars milestone (25K, 30K)
• Production-ready announcement
• Notable new production users
• Breaking changes to embedding API