Ruchy

A systems-oriented scripting language that transpiles to zero-cost Rust, combining Python's ergonomics with Rust's performance guarantees.

// Ruchy: Write like Python, run like Rust
fun analyze(data: DataFrame) -> Result<Statistics> {
    data
    |> filter(col("value") > 0)
    |> groupby("category")
    |> agg([
        col("value").mean().alias("avg"),
        col("value").std().alias("stddev")
    ])
    |> collect()
}

Why Ruchy?

The Problem: Python's ease-of-use comes at a 50-100x performance cost. Rust's performance requires managing lifetimes, traits, and complex syntax.

The Solution: Ruchy provides Python-like syntax that mechanically transforms to idiomatic Rust, achieving:

• <10ms REPL startup for interactive development
• Zero runtime overhead - compiles to native Rust
• Direct Cargo integration - use any Rust crate unchanged
• Native DataFrame operations via Polars

Key Features

🚀 Multiple Execution Modes

# Interactive REPL with JIT compilation
$ ruchy
ruchy> [1..100] |> filter(_ % 2 == 0) |> sum()
2550

# Script execution
$ ruchy run analysis.ruchy

# AOT compilation to native binary
$ ruchy build --release analysis.ruchy

📊 DataFrame-First Design

// DataFrames as primary collection type
let df = df![
    "name": ["Alice", "Bob", "Charlie"],
    "score": [95, 87, 92]
]

let top_performers = df
    |> filter(col("score") > 90)
    |> sort("score", desc: true)

🎯 Zero-Cost Abstractions

// Ruchy source
fun process(items: [T]) -> [T] {
    items |> map(transform) |> filter(validate)
}

// Generated Rust (identical performance)
fn process<T>(items: Vec<T>) -> Vec<T> {
    items.into_iter()
        .map(transform)
        .filter(validate)
        .collect()
}

🔍 Gradual Verification

// Start dynamic
fun quick_prototype(data) = process(data)

// Add types when ready
fun production(data: ValidatedData) -> Result<Output> {
    process(data)?
}

// Add proofs when critical
#[ensures(result.is_sorted())]
fun critical_sort(mut data: Vec<T>) -> Vec<T> {
    data.sort();
    data
}

Installation

Via Cargo (Recommended)

cargo install ruchy-cli

Pre-built Binaries

Download the latest release for your platform from GitHub Releases:

Linux/macOS:

# Download the binary (replace URL with your platform)
curl -LO https://github.com/paiml/ruchy/releases/download/v0.1.0/ruchy-linux-amd64
chmod +x ruchy-linux-amd64
sudo mv ruchy-linux-amd64 /usr/local/bin/ruchy

Windows: Download ruchy-windows-amd64.exe from the releases page.

From Source

git clone https://github.com/paiml/ruchy
cd ruchy
cargo install --path ruchy-cli

Quick Start

1. Create a Ruchy Script

// hello.ruchy
fun greet(name: String) = println("Hello, {name}!")

fun main() {
    ["World", "Rust", "Ruchy"]
    |> map(greet)
}

2. Run It

$ ruchy run hello.ruchy
Hello, World!
Hello, Rust!  
Hello, Ruchy!

3. Compile to Native

$ ruchy build hello.ruchy --release
$ ./hello
Hello, World!
Hello, Rust!
Hello, Ruchy!

Language Tour

Pattern Matching

match value {
    Some(x) if x > 0 => x * 2,
    Some(0) => panic("zero not allowed"),
    None => default_value
}

Actor Concurrency

actor Counter {
    mut count: i32 = 0,
    
    receive {
        Increment => self.count += 1,
        Get(reply) => reply.send(self.count)
    }
}

let counter = spawn Counter()
counter ! Increment
let count = counter ? Get  // Synchronous ask

Pipeline Operators

data
|> validate()
|> transform()
|> aggregate()
|> visualize()

Property Testing

#[property]
fun prop_sort_idempotent(xs: Vec<i32>) {
    let once = xs.sorted()
    let twice = once.sorted()
    assert_eq!(once, twice)
}

Performance

Benchmarks on AMD Ryzen 9 5900X, 32GB RAM:

Binary size: 1.8MB (including minimal runtime)
Compilation: 10k LOC in ~2s (incremental: ~200ms)

Architecture

Source (.ruchy) → Parser → Type Inference → Rust AST → rustc → Native Binary
                    ↓           ↓              ↓
                  REPL     Type Errors    Optimization

Type System

• Bidirectional type checking with Hindley-Milner inference
• Row polymorphism for extensible records
• Refinement types with SMT verification
• Gradual typing with runtime boundary checks

Memory Model

• Affine types with escape analysis
• Automatic Rc/Arc insertion where needed
• Zero allocations for stack-bound values
• Copy-on-write for value semantics

Ecosystem Integration

Using Rust Crates

// Any Rust crate works directly
import tokio::time::sleep
import reqwest::get
import polars::prelude::*

async fun fetch_and_analyze(url: String) -> DataFrame {
    let response = get(url).await?
    let data = response.json().await?
    DataFrame::from(data)
}

In Cargo Projects

# Cargo.toml
[dependencies]
serde = "1.0"

[build-dependencies]
ruchy = "1.0"

// build.rs
fn main() {
    ruchy::compile_glob("src/**/*.ruchy")?;
}

MCP (Model Context Protocol) Support

Native integration for AI/LLM tools:

#[mcp_tool("code_analyzer")]
actor Analyzer {
    #[mcp_handler]
    async fn analyze(code: String) -> Analysis {
        parse(code)
        |> extract_complexity()
        |> generate_suggestions()
    }
}

Quality Enforcement

Integrated PMAT quality gates ensure Toyota Way standards:

$ ruchy build --quality-gate
✓ Complexity: max 8 (threshold: 10)
✓ SATD: 0 found (threshold: 0)
✓ Coverage: 94% (threshold: 80%)
✓ Properties: 127 passing

Documentation

• Language Guide - Complete language reference
• Standard Library - Built-in functions and types
• Cargo Integration - Using Ruchy in Rust projects
• Actor Model - Concurrency and message passing
• Performance Tuning - Optimization strategies

Contributing

We welcome contributions! See CONTRIBUTING.md for:

• Development setup
• Architecture overview
• Testing requirements
• Code style guide

Roadmap

v0.5 (Current)

• Core parser and type inference
• Basic Rust transpilation
• REPL with incremental compilation
• DataFrame operations

v1.0 (Q2 2025)

• Full actor system
• Property testing integration
• LSP implementation
• Stabilized syntax

v2.0 (Q4 2025)

• WASM target
• GPU compute kernels
• Distributed actors
• Formal verification

License

MIT - See LICENSE for details.

Acknowledgments

Ruchy synthesizes ideas from:

• Rust - Ownership, zero-cost abstractions
• Python - Simplicity, readability
• Elixir - Actor model, fault tolerance
• Swift - Progressive disclosure, value semantics
• Kotlin - Null safety, smart casts
• F# - Type providers, computation expressions

Built with obsessive attention to performance and correctness.