# Ruchy - Revolutionary Language with Built-in Formal Verification & BigO Analysis 🚀
[](https://opensource.org/licenses/MIT)
[](https://www.rust-lang.org)
[](./tests)
[](./docs/execution/roadmap.md)
**The world's first programming language with built-in formal verification and automatic BigO complexity analysis.** A functional language that transpiles to idiomatic Rust, featuring revolutionary development tools that don't exist in any other language.
## 🎯 Quick Start
```bash
# Install from crates.io
cargo install ruchy
# Run a one-liner
ruchy -e "println('Hello, World!')"
# Run with JSON output
ruchy -e "2 + 2" --format json
# Start the REPL
ruchy repl
# Run a script
ruchy run script.ruchy
# Enhanced Testing (NEW in v0.9.12)
ruchy test examples/ --coverage --format json
ruchy test --coverage --coverage-format html
```
## ✨ Key Features
### Production-Grade REPL
- **Resource-bounded evaluation**: Memory limits, timeouts, stack depth protection
- **Multiline editing**: Automatic detection of incomplete expressions
- **Syntax highlighting**: Real-time colored output with O(n) performance
- **Tab completion**: Context-aware completions with O(1) keyword lookups
- **Persistent history**: Cross-session command history
### Core Language Features
```ruchy
// Pattern matching with exhaustiveness checking
match value {
0 => "zero",
1..=10 => "small",
_ => "large"
}
// String interpolation
let name = "Ruchy"
println(f"Hello from {name}!")
// Functional programming
[1, 2, 3, 4, 5]
.map(|x| x * 2)
.filter(|x| x > 5)
.reduce(0, |acc, x| acc + x)
// Loop expressions
for i in 1..=5 {
println(i)
}
// Block expressions return values
let result = {
let a = 10
let b = 20
a + b // Returns 30
}
```
### Type System
- Type inference with bidirectional checking
- Option<T> and Result<T, E> types
- Generic functions and structs
- Trait definitions and implementations
### Enhanced Testing Framework (v0.9.12)
- **Coverage analysis**: Line-level tracking with HTML/JSON/text reports
- **Multiple output formats**: text, JSON, JUnit XML for CI/CD integration
- **Professional workflow**: Deno-style development experience
- **Performance optimized**: <20ms overhead for typical test suites
- **Parallel execution**: Concurrent test running for speed
```bash
# Run tests with coverage
ruchy test examples/ --coverage --parallel
# Generate HTML coverage report
ruchy test --coverage --coverage-format html
# CI/CD friendly output
ruchy test --format junit --coverage --coverage-format json
```
## 🛠️ Revolutionary Development Tools
Ruchy provides the world's most advanced development tooling, with groundbreaking features that don't exist in any other programming language:
### 🔬 Formal Verification (`ruchy provability`)
**World's First:** Mathematical correctness guarantees in a system programming language.
```bash
# Basic provability analysis
ruchy provability script.ruchy
# Full formal verification
ruchy provability script.ruchy --verify --verbose
# Contract verification (pre/post-conditions)
ruchy provability script.ruchy --contracts
# Loop invariant checking
ruchy provability script.ruchy --invariants
# Termination analysis
ruchy provability script.ruchy --termination
# Memory safety & bounds checking
ruchy provability script.ruchy --bounds
```
**Features:**
- ✅ **Function purity detection** with side-effect analysis
- ✅ **Recursive function identification** and complexity scoring
- ✅ **Provability scoring** (0-100) with visual indicators
- ✅ **Property-based verification**: termination, memory safety, type safety
- ✅ **Verification report generation** for CI/CD integration
### ⚡ Performance Analysis (`ruchy runtime`)
**World's First:** Automatic BigO algorithmic complexity detection.
```bash
# Basic performance metrics
ruchy runtime script.ruchy
# Execution profiling with hot-spot detection
ruchy runtime script.ruchy --profile --verbose
# Automatic BigO complexity analysis
ruchy runtime script.ruchy --bigo
# Benchmark execution
ruchy runtime script.ruchy --bench
# Compare performance between files
ruchy runtime script.ruchy --compare other.ruchy
# Memory usage analysis
ruchy runtime script.ruchy --memory
```
**Features:**
- ✅ **Automatic BigO detection** (O(1), O(n), O(n²), O(n³))
- ✅ **Nested loop complexity analysis** with worst-case scenarios
- ✅ **Function-level profiling** with execution timing
- ✅ **Performance bottleneck identification**
- ✅ **Optimization scoring** with specific recommendations
### 📊 AST Analysis (`ruchy ast`)
Comprehensive AST inspection and analysis tools.
```bash
# Pretty-printed AST
ruchy ast script.ruchy
# JSON output for tooling
ruchy ast script.ruchy --json --output ast.json
# Visual AST graph (DOT format)
ruchy ast script.ruchy --graph --verbose
# Complexity metrics
ruchy ast script.ruchy --metrics
# Symbol table analysis
ruchy ast script.ruchy --symbols
# Dependency analysis
ruchy ast script.ruchy --deps
```
**Features:**
- ✅ **JSON serialization** for tooling integration
- ✅ **DOT graph generation** for visualization
- ✅ **Cyclomatic complexity** calculation
- ✅ **Symbol usage analysis** with unused detection
- ✅ **Module dependency tracking**
### 🎨 Code Formatting (`ruchy fmt`)
Professional code formatting with configurable styles.
```bash
# Format a single file
ruchy fmt script.ruchy
# Format all project files
ruchy fmt --all
# Check formatting (CI mode)
ruchy fmt script.ruchy --check
# Custom configuration
ruchy fmt script.ruchy --line-width 100 --indent 2
```
### 🔍 Code Linting (`ruchy lint`)
Grammar-based code analysis with auto-fix capabilities.
```bash
# Basic linting
ruchy lint script.ruchy
# Auto-fix issues
ruchy lint script.ruchy --fix
# Strict mode (all warnings as errors)
ruchy lint --strict
# Specific rule categories
ruchy lint --rules unused,style,complexity
```
### 🧪 Testing with Coverage (`ruchy test`)
Professional testing framework with coverage analysis.
```bash
# Run all tests with coverage
ruchy test --coverage
# Generate HTML coverage report
ruchy test --coverage --coverage-format html
# Parallel test execution
ruchy test --parallel
# Set coverage threshold
ruchy test --coverage --threshold 80
```
### Innovation Comparison
| Formal Verification | ✅ Built-in | ❌ | ❌ | ❌ |
| Automatic BigO Analysis | ✅ Built-in | ❌ | ❌ | ❌ |
| Mathematical Provability | ✅ Built-in | ❌ | ❌ | ❌ |
| AST Visualization | ✅ Built-in | ❌ | ❌ | ❌ |
| Coverage Analysis | ✅ Built-in | ✅ | ✅ | 🔧 External |
| Auto-formatting | ✅ Built-in | ✅ | ✅ | ✅ |
## 🏗️ Architecture
### For Rust Developers
The Ruchy interpreter showcases advanced Rust patterns and optimizations. **[Read the detailed Interpreter Architecture](./docs/interpreter.md)** to learn about:
- **Resource-bounded evaluation** with `Instant` deadlines and memory tracking
- **Zero-allocation patterns** using `&str` and arena allocators
- **O(1) HashSet lookups** replacing O(n²) algorithms
- **Modular complexity management** keeping all functions under 50 cyclomatic complexity
- **Property-based testing** with `proptest` for invariant verification
- **Fuzz testing** for crash resistance
### Interpreter (v0.8.0 - Complexity Optimized)
- **Cyclomatic complexity**: Reduced from 209 to 50 (76% reduction)
- **Display formatting**: Extracted to modular helpers (<30 complexity each)
- **O(n²) algorithms eliminated**: HashSet-based lookups for O(1) performance
- **Memory tracking**: Per-evaluation resource bounds with `AtomicUsize`
### Transpiler
- Direct Rust code generation via `quote!` macros
- Zero-cost abstractions with `syn` and `proc-macro2`
- Hygienic macro expansion
- Incremental compilation support
## 📊 Quality Metrics
```
Tests: 271 passing (library)
34 passing (interpreter core)
10 property tests
10 fuzz tests
33 doctests
Code Coverage: >80%
Complexity: All functions <50 (enforced by PMAT)
Performance: 50MB/s parsing throughput
```
## 🔧 Development
```bash
# Run tests
make test
# Check quality gates
make lint
# Run benchmarks
make bench
# Generate documentation
cargo doc --open
```
### Quality Gates (Toyota Way - Zero Defects)
All commits must pass:
1. Core interpreter reliability tests
2. REPL functionality tests
3. Cyclomatic complexity <50
4. Zero clippy warnings
5. 80% test coverage minimum
See [CLAUDE.md](./CLAUDE.md) for the full development protocol.
## 📚 Documentation
- **[Interpreter Architecture](./docs/interpreter.md)** - Deep dive into the v0.8.0 complexity-optimized interpreter
- [Language Specification](./docs/SPECIFICATION.md) - Complete language reference
- [Roadmap](./ROADMAP.md) - Development progress and priorities
- [Contributing Guidelines](./CONTRIBUTING.md) - How to contribute
## 🚀 Current Focus (v0.8.0)
- ✅ Interpreter complexity reduction (209 → 50)
- ✅ O(n²) algorithm elimination
- ✅ Display formatting modularization
- ✅ Extended test coverage (property, fuzz, examples)
- 🔄 Binary compilation via LLVM
- 🔄 DataFrame operations
- 🔄 Actor system
## 📦 Installation
### From crates.io
```bash
cargo install ruchy ruchy-cli
```
### From source
```bash
git clone https://github.com/yourusername/ruchy
cd ruchy
cargo build --release
cargo install --path . --path ruchy-cli
```
## 🤝 Contributing
Contributions welcome! Please read [CONTRIBUTING.md](./CONTRIBUTING.md) first.
Key principles:
- Zero defects (Toyota Way)
- Complexity budget (<50 per function)
- Test coverage >80%
- All PRs must pass quality gates
## 📄 License
MIT - See [LICENSE](./LICENSE) for details.
---