AI models default to Python. Python is often the wrong choice for performance-critical code. Pivot analyzes your slow Python/Ruby/JS, rewrites it to Go/Rust/C++, and proves the output is statistically identical.

$ naab-lang pivot.naab analyze app.py

  Hotspot: process_batch() — 847ms avg, called 10,000x/min
  Candidate: rewrite to Go

$ naab-lang pivot.naab rewrite app.py:process_batch --target go --prove

  ✓ Rewrite complete
  ✓ Correctness verified (1,000 test cases, 99.99% parity)
  ✓ Speedup: 34x  (847ms → 24ms)

3–60x speedups · 8 target languages · Statistical proof of correctness · Part of the NAAb ecosystem

• Automatic optimization — AST-based analysis detects hotspots automatically
• 8 target languages — Go, C++, Rust, Ruby, JS, PHP, Zig, Julia
• Proven correctness — Statistical parity validation (99.99% confidence, 100+ test cases)
• Real-world speedups — 3-60x faster, 70-96% memory reduction
• Incremental migration — Optimize critical paths, leave the rest unchanged
• Web dashboard — Interactive performance visualization

See NAAb Pivot optimizing Python code to Go with proven performance improvements:

CPU-intensive computation running slowly in Python:

Visual benchmark showing the dramatic speedup:

Results:

• Python: 2,843 ms (baseline)
• Go: 812 ms (optimized)
• Speedup: 3.5x faster
• Memory: 72% reduction
• Correctness: ✓ Parity CERTIFIED (99.99% confidence, 100 test cases)

Pivot achieved:

• Automatic hotspot detection
• Python → Go code generation
• Mathematical correctness proof (99.99%)
• 3.5x performance improvement

Try the demo yourself:

cd demos
./pivot-demo.sh

See DEMO_GUIDE.md for recording instructions.

# Clone with NAAb submodule
git clone --recursive https://github.com/b-macker/naab-pivot.git
cd naab-pivot

# Build NAAb language
bash build.sh

# Analyze slow code
./naab/build/naab-lang pivot.naab analyze slow.py

# Full evolution pipeline
./naab/build/naab-lang pivot.naab evolve slow.py --profile balanced

Input (slow.py):

def heavy_computation(n):
    result = 0.0
    for i in range(n):
        result += (i ** 2) ** 0.5
    return result

# Baseline: 2843ms for n=10,000,000

Run Pivot:

./naab/build/naab-lang pivot.naab evolve slow.py

Output:

✓ Analysis complete: 1 function detected (complexity: 8)
✓ Generated optimized Go version
✓ Parity CERTIFIED (99.99% confidence, 100 test cases)
✓ Performance: 812ms (3.5x faster)

Generated Go code:

package main
import ("fmt"; "math"; "os"; "strconv")

func heavyComputation(n int) float64 {
    result := 0.0
    for i := 0; i < n; i++ {
        result += math.Sqrt(math.Pow(float64(i), 2))
    }
    return result
}

func main() {
    // Auto-generated vessel code...
}

10 real-world examples with proven performance improvements:

See examples/ for complete code and benchmarks.

• Analyze — Multi-language AST-based code analyzer
• Synthesize — Template-based code generator with caching
• Validate — Statistical parity validator (99.99% confidence)
• Benchmark — Performance tracking with regression detection
• Migrate — Incremental migration helper for large codebases

ultra-safe conservative balanced aggressive experimental minimal embedded wasm

go cpp rust ruby javascript php zig julia

• Analyzers: ML detector, crypto detector, I/O detector
• Synthesizers: SIMD optimizer, GPU optimizer, parallel optimizer
• Validators: Fuzzer, property checker, formal verifier

JSON HTML CSV SARIF Markdown

Use NAAb Pivot in your CI/CD pipeline:

name: Optimize Performance

on: [push, pull_request]

jobs:
  evolve:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - uses: b-macker/naab-pivot@v1
        with:
          file: src/critical_path.py
          profile: balanced
          validate: true

      - name: Check Results
        run: cat vessels/benchmark-report.json

• Quick Start — 5-minute tutorial
• Getting Started — Installation and setup
• Architecture — System design and data flow
• CLI Reference — All commands and flags
• API Reference — Module documentation
• Examples — 10 real-world projects
• Troubleshooting — Common issues
• FAQ — Frequently asked questions

Source Code (Python/Ruby/JS)
    |
Analyzer (AST parsing, complexity analysis)
    |
Synthesizer (template-based code generation)
    |
Compiler (parallel builds with caching)
    |
Validator (statistical parity testing)
    |
Benchmark (performance tracking)
    |
Report (JSON/HTML/CSV/SARIF/Markdown)

• 134+ files created
• ~28,000 lines of code
• 46 commits (100% governance compliance)
• 17/17 tests passing
• 10 proven examples
• 22 documentation files

NAAb Pivot is part of the NAAb ecosystem:

• NAAb Language — Core polyglot scripting language with governance
• NAAb BOLO — Code governance & AI validation (50+ checks)
• NAAb Pivot (this project) — Code evolution & optimization (3-60x speedups)
• NAAb Passage — Data gateway & PII protection (zero leakage)

Contributions are welcome! See CONTRIBUTING.md for build instructions and guidelines.

• Additional target languages (V, Nim, Crystal, Mojo, Odin)
• Performance optimizations
• New optimization profiles
• IDE integrations
• Package manager support

MIT License - see LICENSE for details.

Brandon Mackert - @b-macker

NAAb Pivot — Polyglot evolution made simple.