Velocicode 0.5.0__py3-none-any.whl

velocicode/benchmarks/fibonacci/cpp/main.cpp

@@ -0,0 +1,16 @@
+#include <iostream>
+#include <cstdlib>
+
+int fib(int n) {
+    if (n <= 1) return n;
+    return fib(n - 1) + fib(n - 2);
+}
+
+int main(int argc, char* argv[]) {
+    int n = 35;
+    if (argc > 1) {
+        n = std::atoi(argv[1]);
+    }
+    std::cout << fib(n) << std::endl;
+    return 0;
+}

velocicode/benchmarks/fibonacci/go/main.go

@@ -0,0 +1,25 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"strconv"
+)
+
+func fib(n int) int {
+	if n <= 1 {
+		return n
+	}
+	return fib(n-1) + fib(n-2)
+}
+
+func main() {
+	n := 35
+	if len(os.Args) > 1 {
+		val, err := strconv.Atoi(os.Args[1])
+		if err == nil {
+			n = val
+		}
+	}
+	fmt.Println(fib(n))
+}

velocicode/benchmarks/fibonacci/javascript/main.js

@@ -0,0 +1,9 @@
+function fib(n) {
+    if (n <= 1) return n;
+    return fib(n - 1) + fib(n - 2);
+}
+
+const args = process.argv.slice(2);
+const n = args.length > 0 ? parseInt(args[0]) : 35;
+
+console.log(fib(n));

velocicode/benchmarks/fibonacci/python/main.py

@@ -0,0 +1,12 @@
+import sys
+
+def fib(n):
+    if n <= 1:
+        return n
+    return fib(n - 1) + fib(n - 2)
+
+if __name__ == "__main__":
+    n = 35
+    if len(sys.argv) > 1:
+        n = int(sys.argv[1])
+    print(fib(n))

velocicode/benchmarks/fibonacci/rust/main.rs

@@ -0,0 +1,18 @@
+use std::env;
+
+fn fib(n: u32) -> u32 {
+    if n <= 1 {
+        return n;
+    }
+    fib(n - 1) + fib(n - 2)
+}
+
+fn main() {
+    let args: Vec<String> = env::args().collect();
+    let n = if args.len() > 1 {
+        args[1].parse().unwrap_or(35)
+    } else {
+        35
+    };
+    println!("{}", fib(n));
+}

velocicode/benchmarks/matrix_mul/cpp/main.cpp

@@ -0,0 +1,41 @@
+#include <iostream>
+#include <vector>
+#include <cstdlib>
+#include <random>
+
+using namespace std;
+
+vector<vector<double>> generate_matrix(int n) {
+    vector<vector<double>> m(n, vector<double>(n));
+    random_device rd;
+    mt19937 gen(rd());
+    uniform_real_distribution<> dis(0.0, 1.0);
+    for(int i=0; i<n; ++i)
+        for(int j=0; j<n; ++j)
+            m[i][j] = dis(gen);
+    return m;
+}
+
+vector<vector<double>> mat_mul(const vector<vector<double>>& A, const vector<vector<double>>& B, int n) {
+    vector<vector<double>> C(n, vector<double>(n, 0.0));
+    for (int i = 0; i < n; ++i) {
+        for (int k = 0; k < n; ++k) {
+            for (int j = 0; j < n; ++j) {
+                C[i][j] += A[i][k] * B[k][j];
+            }
+        }
+    }
+    return C;
+}
+
+int main(int argc, char* argv[]) {
+    int n = 200;
+    if (argc > 1) n = atoi(argv[1]);
+
+    auto A = generate_matrix(n);
+    auto B = generate_matrix(n);
+    auto C = mat_mul(A, B, n);
+    
+    cout << C[0][0] << endl;
+    return 0;
+}

velocicode/benchmarks/matrix_mul/go/main.go

@@ -0,0 +1,49 @@
+package main
+
+import (
+	"fmt"
+	"math/rand"
+	"os"
+	"strconv"
+)
+
+func generateMatrix(n int) [][]float64 {
+	m := make([][]float64, n)
+	for i := range m {
+		m[i] = make([]float64, n)
+		for j := range m[i] {
+			m[i][j] = rand.Float64()
+		}
+	}
+	return m
+}
+
+func matMul(a, b [][]float64, n int) [][]float64 {
+	c := make([][]float64, n)
+	for i := range c {
+		c[i] = make([]float64, n)
+	}
+	
+	for i := 0; i < n; i++ {
+		for k := 0; k < n; k++ {
+			for j := 0; j < n; j++ {
+				c[i][j] += a[i][k] * b[k][j]
+			}
+		}
+	}
+	return c
+}
+
+func main() {
+	n := 200
+	if len(os.Args) > 1 {
+		if val, err := strconv.Atoi(os.Args[1]); err == nil {
+			n = val
+		}
+	}
+
+	a := generateMatrix(n)
+	b := generateMatrix(n)
+	c := matMul(a, b, n)
+	fmt.Println(c[0][0])
+}

velocicode/benchmarks/matrix_mul/javascript/main.js

@@ -0,0 +1,31 @@
+function generateMatrix(n) {
+    const m = [];
+    for (let i = 0; i < n; i++) {
+        m[i] = [];
+        for (let j = 0; j < n; j++) {
+            m[i][j] = Math.random();
+        }
+    }
+    return m;
+}
+
+function matMul(A, B, n) {
+    const C = [];
+    for (let i = 0; i < n; i++) {
+        C[i] = new Float64Array(n);
+        for (let k = 0; k < n; k++) {
+            for (let j = 0; j < n; j++) {
+                C[i][j] += A[i][k] * B[k][j];
+            }
+        }
+    }
+    return C;
+}
+
+const args = process.argv.slice(2);
+const n = args.length > 0 ? parseInt(args[0]) : 200;
+
+const A = generateMatrix(n);
+const B = generateMatrix(n);
+const C = matMul(A, B, n);
+console.log(C[0][0]);

velocicode/benchmarks/matrix_mul/python/main.py

@@ -0,0 +1,25 @@
+import sys
+import random
+
+def generate_matrix(n):
+    return [[random.random() for _ in range(n)] for _ in range(n)]
+
+def mat_mul(A, B, n):
+    C = [[0] * n for _ in range(n)]
+    for i in range(n):
+        for j in range(n):
+            sum_val = 0
+            for k in range(n):
+                sum_val += A[i][k] * B[k][j]
+            C[i][j] = sum_val
+    return C
+
+if __name__ == "__main__":
+    n = 200
+    if len(sys.argv) > 1:
+        n = int(sys.argv[1])
+    
+    A = generate_matrix(n)
+    B = generate_matrix(n)
+    C = mat_mul(A, B, n)
+    print(C[0][0]) # prevent optimization

velocicode/benchmarks/matrix_mul/rust/main.rs

@@ -0,0 +1,37 @@
+use std::env;
+
+fn generate_matrix(n: usize) -> Vec<Vec<f64>> {
+    let mut m = vec![vec![0.0; n]; n];
+    for i in 0..n {
+        for j in 0..n {
+            m[i][j] = (i as f64 + j as f64) * 0.001; // Simple deterministic generation
+        }
+    }
+    m
+}
+
+fn mat_mul(a: &Vec<Vec<f64>>, b: &Vec<Vec<f64>>, n: usize) -> Vec<Vec<f64>> {
+    let mut c = vec![vec![0.0; n]; n];
+    for i in 0..n {
+        for k in 0..n {
+            for j in 0..n {
+                c[i][j] += a[i][k] * b[k][j];
+            }
+        }
+    }
+    c
+}
+
+fn main() {
+    let args: Vec<String> = env::args().collect();
+    let n = if args.len() > 1 {
+        args[1].parse().unwrap_or(200)
+    } else {
+        200
+    };
+
+    let a = generate_matrix(n);
+    let b = generate_matrix(n);
+    let c = mat_mul(&a, &b, n);
+    println!("{}", c[0][0]);
+}

velocicode/benchmarks/primes/cpp/main.cpp

@@ -0,0 +1,28 @@
+#include <iostream>
+#include <vector>
+#include <cstdlib>
+
+using namespace std;
+
+int sieve(int n) {
+    vector<bool> primes(n + 1, true);
+    for (int p = 2; p * p <= n; p++) {
+        if (primes[p] == true) {
+            for (int i = p * p; i <= n; i += p)
+                primes[i] = false;
+        }
+    }
+    
+    int count = 0;
+    for (int p = 2; p <= n; p++)
+        if (primes[p]) count++;
+    return count;
+}
+
+int main(int argc, char* argv[]) {
+    int n = 1000000;
+    if (argc > 1) n = atoi(argv[1]);
+
+    cout << sieve(n) << endl;
+    return 0;
+}

velocicode/benchmarks/primes/go/main.go

@@ -0,0 +1,40 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"strconv"
+)
+
+func sieve(n int) int {
+	primes := make([]bool, n+1)
+	for i := 0; i <= n; i++ {
+		primes[i] = true
+	}
+
+	for p := 2; p*p <= n; p++ {
+		if primes[p] == true {
+			for i := p * p; i <= n; i += p {
+				primes[i] = false
+			}
+		}
+	}
+
+	count := 0
+	for p := 2; p <= n; p++ {
+		if primes[p] {
+			count++
+		}
+	}
+	return count
+}
+
+func main() {
+	n := 1000000
+	if len(os.Args) > 1 {
+		if val, err := strconv.Atoi(os.Args[1]); err == nil {
+			n = val
+		}
+	}
+	fmt.Println(sieve(n))
+}

velocicode/benchmarks/primes/javascript/main.js

@@ -0,0 +1,20 @@
+function sieve(n) {
+    const primes = new Uint8Array(n + 1).fill(1);
+
+    for (let p = 2; p * p <= n; p++) {
+        if (primes[p] === 1) {
+            for (let i = p * p; i <= n; i += p)
+                primes[i] = 0;
+        }
+    }
+
+    let count = 0;
+    for (let p = 2; p <= n; p++)
+        if (primes[p] === 1) count++;
+    return count;
+}
+
+const args = process.argv.slice(2);
+const n = args.length > 0 ? parseInt(args[0]) : 1000000;
+
+console.log(sieve(n));

velocicode/benchmarks/primes/python/main.py

@@ -0,0 +1,24 @@
+import sys
+
+def sieve(n):
+    primes = [True] * (n + 1)
+    p = 2
+    while (p * p <= n):
+        if (primes[p] == True):
+            for i in range(p * p, n + 1, p):
+                primes[i] = False
+        p += 1
+    
+    # Count primes
+    count = 0
+    for p in range(2, n + 1):
+        if primes[p]:
+            count += 1
+    return count
+
+if __name__ == "__main__":
+    n = 1000000
+    if len(sys.argv) > 1:
+        n = int(sys.argv[1])
+    
+    print(sieve(n))

velocicode/benchmarks/primes/rust/main.rs

@@ -0,0 +1,35 @@
+use std::env;
+
+fn sieve(n: usize) -> i32 {
+    let mut primes = vec![true; n + 1];
+    let mut p = 2;
+    while p * p <= n {
+        if primes[p] {
+            let mut i = p * p;
+            while i <= n {
+                primes[i] = false;
+                i += p;
+            }
+        }
+        p += 1;
+    }
+    
+    let mut count = 0;
+    for p in 2..=n {
+        if primes[p] {
+            count += 1;
+        }
+    }
+    count
+}
+
+fn main() {
+    let args: Vec<String> = env::args().collect();
+    let n = if args.len() > 1 {
+        args[1].parse().unwrap_or(1000000)
+    } else {
+        1000000
+    };
+
+    println!("{}", sieve(n));
+}

velocicode/benchmarks/quicksort/cpp/main.cpp

@@ -0,0 +1,24 @@
+#include <iostream>
+#include <vector>
+#include <cstdlib>
+#include <algorithm>
+#include <random>
+
+using namespace std;
+
+int main(int argc, char* argv[]) {
+    int n = 1000000;
+    if (argc > 1) n = atoi(argv[1]);
+
+    vector<int> data(n);
+    random_device rd;
+    mt19937 gen(rd());
+    uniform_int_distribution<> dis(0, 1000000);
+
+    for(int i=0; i<n; ++i) data[i] = dis(gen);
+
+    sort(data.begin(), data.end());
+
+    cout << data[0] << endl;
+    return 0;
+}

velocicode/benchmarks/quicksort/go/main.go

@@ -0,0 +1,26 @@
+package main
+
+import (
+	"fmt"
+	"math/rand"
+	"os"
+	"sort"
+	"strconv"
+)
+
+func main() {
+	n := 1000000
+	if len(os.Args) > 1 {
+		if val, err := strconv.Atoi(os.Args[1]); err == nil {
+			n = val
+		}
+	}
+
+	data := make([]int, n)
+	for i := 0; i < n; i++ {
+		data[i] = rand.Intn(1000000)
+	}
+
+	sort.Ints(data)
+	fmt.Println(data[0])
+}

velocicode/benchmarks/quicksort/javascript/main.js

@@ -0,0 +1,11 @@
+const args = process.argv.slice(2);
+const n = args.length > 0 ? parseInt(args[0]) : 1000000;
+
+const data = new Int32Array(n);
+for (let i = 0; i < n; i++) {
+    data[i] = Math.floor(Math.random() * 1000000);
+}
+
+data.sort();
+
+console.log(data[0]);

velocicode/benchmarks/quicksort/python/main.py

@@ -0,0 +1,26 @@
+import sys
+import random
+import time
+
+sys.setrecursionlimit(2000000)
+
+def quick_sort(arr):
+    if len(arr) <= 1:
+        return arr
+    pivot = arr[len(arr) // 2]
+    left = [x for x in arr if x < pivot]
+    middle = [x for x in arr if x == pivot]
+    right = [x for x in arr if x > pivot]
+    return quick_sort(left) + middle + quick_sort(right)
+
+if __name__ == "__main__":
+    n = 1000000
+    if len(sys.argv) > 1:
+        n = int(sys.argv[1])
+    
+    # Generate random data
+    data = [random.randint(0, 1000000) for _ in range(n)]
+    
+    sorted_data = quick_sort(data)
+    # Print first element to prevent optimization
+    print(sorted_data[0])

velocicode/benchmarks/quicksort/rust/main.rs

@@ -0,0 +1,40 @@
+use std::env;
+
+struct Lcg {
+    state: u64,
+}
+
+impl Lcg {
+    fn new(seed: u64) -> Self {
+        Lcg { state: seed }
+    }
+
+    fn next(&mut self) -> u32 {
+        // Linear Congruential Generator config (same as glibc's rand)
+        self.state = (self.state.wrapping_mul(1103515245).wrapping_add(12345)) % 2147483648;
+        self.state as u32
+    }
+    
+    fn gen_range(&mut self, range: std::ops::Range<i32>) -> i32 {
+        let min = range.start;
+        let max = range.end;
+        let width = (max - min) as u32;
+        (self.next() % width) as i32 + min
+    }
+}
+
+fn main() {
+    let args: Vec<String> = env::args().collect();
+    let n = if args.len() > 1 {
+        args[1].parse().unwrap_or(1000000)
+    } else {
+        1000000
+    };
+
+    let mut rng = Lcg::new(12345);
+    let mut data: Vec<i32> = (0..n).map(|_| rng.gen_range(0..1000000)).collect();
+
+    data.sort();
+
+    println!("{}", data[0]);
+}

velocicode/config.yaml

@@ -0,0 +1,16 @@
+languages:
+  python:
+    run: "python3 {source}"
+  cpp:
+    compile: "g++ -O3 -std=c++11 {source} -o {out}"
+    run: "{out}"
+  rust:
+    compile: "rustc -O {source} -o {out}"
+    run: "{out}"
+  javascript:
+    run: "node {source}"
+  go:
+    compile: "go build -o {out} {source}"
+    run: "{out}"
+dependencies:
+  rust: [rand]

velocicode/main.py

@@ -0,0 +1,239 @@
+import argparse
+import yaml
+import os
+import sys
+from glob import glob
+import shutil
+from .runner import BenchmarkRunner
+from .reporter import print_table
+from .system_info import get_system_info
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Confirm
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich import print as rprint
+
+console = Console()
+
+def check_dependencies(config, verbose=True):
+    if verbose:
+        rprint(Panel("Checking System Dependencies", style="bold blue"))
+    
+    languages = config.get('languages', {})
+    valid_langs = set()
+    missing_langs = set()
+    
+    for lang, cfg in languages.items():
+        # Determine the command to check
+        # If 'compile' exists, check the compiler. Else check 'run'.
+        cmd_str = cfg.get('compile') or cfg.get('run')
+        if not cmd_str:
+            if verbose:
+                rprint(f"[yellow]WARN[/yellow] {lang}: No command defined")
+            continue
+            
+        # simpler parsing: assume command is the first word
+        program = cmd_str.split()[0]
+        
+        path = shutil.which(program)
+        if path:
+            if verbose:
+                rprint(f"[green]✔[/green] {lang:<12} (Found: [cyan]{program}[/cyan])")
+            valid_langs.add(lang)
+        else:
+            if verbose:
+                rprint(f"[red]✘[/red] {lang:<12} (Missing: [bold]{program}[/bold])")
+            missing_langs.add(lang)
+            
+    return valid_langs, missing_langs
+
+
+def get_base_dir():
+    return os.path.dirname(os.path.abspath(__file__))
+
+def load_config():
+    path = os.path.join(get_base_dir(), "config.yaml")
+    if not os.path.exists(path):
+        print(f"Config file not found: {path}")
+        sys.exit(1)
+    with open(path, 'r') as f:
+        return yaml.safe_load(f)
+
+def discover_benchmarks():
+    base_dir = os.path.join(get_base_dir(), "benchmarks")
+    # Structure: benchmarks/<algo>/<lang>/<file>
+    # We want to find all <algo> directories
+    if not os.path.exists(base_dir):
+        return []
+    return [d for d in os.listdir(base_dir) if os.path.isdir(os.path.join(base_dir, d))]
+
+def main():
+    parser = argparse.ArgumentParser(description="Velocicode - Programming Language Speed Benchmark Tool")
+    parser.add_argument("action", choices=["run", "list", "check"], help="Action to perform")
+    parser.add_argument("--filter-algo", help="Filter by specific algorithm name")
+    parser.add_argument("--filter-lang", help="Filter by specific languages (comma separated)")
+    parser.add_argument("--iter", type=int, default=5, help="Number of iterations per benchmark")
+    parser.add_argument("--json", help="Export results to a JSON file")
+    parser.add_argument("--html", help="Export results to an interactive HTML report")
+    
+    args = parser.parse_args()
+    
+    config = load_config()
+    
+    if args.action == "check":
+        check_dependencies(config)
+        return
+
+    runner = BenchmarkRunner(config)
+    
+    algos = discover_benchmarks()
+    if args.filter_algo:
+        algos = [a for a in algos if a == args.filter_algo]
+        
+    target_langs = None
+    if args.filter_lang:
+        target_langs = args.filter_lang.split(',')
+
+    results = []
+
+    if args.action == "list":
+        print("Available benchmarks:")
+        for a in algos:
+            print(f" - {a}")
+        return
+
+    if args.action == "run":
+        # 1. Display System Info
+        sys_info = get_system_info()
+        info_text = f"""
+[bold]OS:[/bold]   {sys_info['os']}
+[bold]CPU:[/bold]  {sys_info['cpu']}
+[bold]Arch:[/bold] {sys_info['arch']}
+[bold]RAM:[/bold]  {sys_info['ram']}
+"""
+        rprint(Panel(info_text.strip(), title="System Information", border_style="green"))
+
+        # 2. Check Dependencies
+        valid_langs, missing_langs = check_dependencies(config, verbose=False)
+        
+        if missing_langs:
+            rprint(f"[yellow]Warning: The following languages are missing:[/yellow] [bold]{', '.join(missing_langs)}[/bold]")
+            if not Confirm.ask("Do you want to continue running valid languages only?"):
+                rprint("[red]Aborted.[/red]")
+                return
+
+        base_dir = os.path.join(get_base_dir(), "benchmarks")
+        
+        # Collect all tasks first
+        tasks_to_run = []
+        for algo in algos:
+            algo_dir = os.path.join(base_dir, algo)
+            lang_dirs = [d for d in os.listdir(algo_dir) if os.path.isdir(os.path.join(algo_dir, d)) and d != 'bin']
+            
+            for lang in lang_dirs:
+                if target_langs and lang not in target_langs:
+                    continue
+                
+                # SKIP if missing
+                if lang in missing_langs:
+                    continue
+                
+                ext_map = {
+                    'python': 'main.py',
+                    'cpp': 'main.cpp',
+                    'rust': 'main.rs',
+                    'go': 'main.go',
+                    'javascript': 'main.js'
+                }
+                expected_file = ext_map.get(lang)
+                if not expected_file:
+                    continue
+                full_path = os.path.join(algo_dir, lang, expected_file)
+                if not os.path.exists(full_path):
+                    continue
+                tasks_to_run.append((algo, lang, full_path))
+
+        if not tasks_to_run:
+            rprint("[yellow]No benchmarks found to run.[/yellow]")
+            return
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True
+        ) as progress:
+            for algo, lang, full_path in tasks_to_run:
+                # Initial task description
+                desc_tpl = f"[bold cyan]{algo}[/bold cyan] ([magenta]{lang}[/magenta])"
+                task_id = progress.add_task(f"{desc_tpl}: Starting...", total=None)
+                
+                def update_status(msg):
+                    # update progress description
+                    progress.update(task_id, description=f"{desc_tpl}: {msg}")
+                
+                stats = runner.run_benchmark(lang, full_path, iterations=args.iter, on_status=update_status)
+                progress.remove_task(task_id)
+                
+                if stats:
+                    results.append({
+                        'benchmark': algo,
+                        'language': lang,
+                        **stats
+                    })
+
+        print_table(results)
+        
+        if args.json:
+            import json
+            with open(args.json, 'w') as f:
+                json.dump(results, f, indent=2)
+            rprint(f"[green]JSON results exported to:[/green] {args.json}")
+            
+        if args.html:
+            from .report_generator import generate_html_report
+            generate_html_report(results, args.html)
+            rprint(f"[green]HTML report generated at:[/green] {args.html}")
+
+def interactive_menu():
+    rprint(Panel.fit("[bold cyan]Velocicode[/bold cyan]\n[dim]High-Performance Benchmark CLI[/dim]", title="Welcome", border_style="blue"))
+    print("1. Run All Benchmarks")
+    print("2. Run Specific Algorithm")
+    print("3. Run Specific Language")
+    print("4. Check Dependencies")
+    print("5. Exit")
+    
+    choice = input("Enter choice: ").strip()
+    
+    if choice == '1':
+        return ["run"]
+    elif choice == '2':
+        algos = discover_benchmarks()
+        print("\n[bold]Available Algorithms:[/bold]")
+        for i, a in enumerate(algos):
+            print(f"{i+1}. {a}")
+        idx = input("Select algorithm number: ").strip()
+        try:
+            algo = algos[int(idx)-1]
+            return ["run", "--filter-algo", algo]
+        except (ValueError, IndexError):
+            print("Invalid selection.")
+            return interactive_menu()
+    elif choice == '3':
+        lang = input("Enter language (e.g. python, cpp): ").strip()
+        return ["run", "--filter-lang", lang]
+    elif choice == '4':
+        return ["check"]
+    elif choice == '5':
+        sys.exit(0)
+    else:
+        print("Invalid choice.")
+        return interactive_menu()
+
+if __name__ == "__main__":
+    if len(sys.argv) == 1:
+        args = interactive_menu()
+        # Hack: modify sys.argv so argparse parses our generated args
+        sys.argv = [sys.argv[0]] + args
+        main()
+    else:
+        main()

velocicode/report_generator.py

@@ -0,0 +1,143 @@
+import json
+import datetime
+
+HTML_TEMPLATE = """
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Velocicode Benchmark Report</title>
+    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+    <style>
+        body {{ font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; margin: 0; padding: 20px; background: #f4f6f8; }}
+        .container {{ max-width: 1000px; margin: 0 auto; background: white; padding: 30px; border-radius: 8px; box-shadow: 0 2px 5px rgba(0,0,0,0.1); }}
+        h1 {{ color: #2c3e50; border-bottom: 2px solid #3498db; padding-bottom: 10px; }}
+        .meta {{ color: #7f8c8d; font-size: 0.9em; margin-bottom: 30px; }}
+        .benchmark-section {{ margin-bottom: 50px; }}
+        .chart-container {{ position: relative; height: 300px; width: 100%; }}
+        table {{ width: 100%; border-collapse: collapse; margin-top: 20px; }}
+        th, td {{ padding: 10px; text-align: left; border-bottom: 1px solid #eee; }}
+        th {{ background-color: #f8f9fa; }}
+        .rank-1 {{ color: #f1c40f; font-weight: bold; }} /* Gold */
+        .rank-2 {{ color: #95a5a6; font-weight: bold; }} /* Silver */
+        .rank-3 {{ color: #cd7f32; font-weight: bold; }} /* Bronze */
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>Velocicode Report</h1>
+        <div class="meta">Generated on: {date}</div>
+        
+        <div id="charts"></div>
+    </div>
+
+    <script>
+        const results = {results_json};
+
+        // Group results by benchmark
+        const grouped = {{}};
+        results.forEach(r => {{
+            if (!grouped[r.benchmark]) grouped[r.benchmark] = [];
+            grouped[r.benchmark].push(r);
+        }});
+
+        const container = document.getElementById('charts');
+
+        // Color palette for languages
+        const colors = {{
+            'python': '#3572A5',
+            'cpp': '#f34b7d',
+            'rust': '#dea584',
+            'go': '#00ADD8',
+            'javascript': '#f1e05a'
+        }};
+
+        for (const [benchName, items] of Object.entries(grouped)) {{
+            // Sort by mean time
+            items.sort((a, b) => a.mean - b.mean);
+            
+            // Create Section
+            const section = document.createElement('div');
+            section.className = 'benchmark-section';
+            
+            const title = document.createElement('h2');
+            title.textContent = `Benchmark: ${{benchName}}`;
+            section.appendChild(title);
+            
+            // Canvas for Chart
+            const chartDiv = document.createElement('div');
+            chartDiv.className = 'chart-container';
+            const canvas = document.createElement('canvas');
+            chartDiv.appendChild(canvas);
+            section.appendChild(chartDiv);
+            
+            // Table
+            const table = document.createElement('table');
+            table.innerHTML = `
+                <thead>
+                    <tr>
+                        <th>Rank</th>
+                        <th>Language</th>
+                        <th>Time (s)</th>
+                        <th>Relative Speed</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    ${{items.map((item, index) => {{
+                        const relative = (item.mean / items[0].mean).toFixed(2) + 'x';
+                        let rankClass = '';
+                        let rankIcon = index + 1;
+                        if (index === 0) {{ rankIcon = '🥇'; rankClass='rank-1'; }}
+                        if (index === 1) {{ rankIcon = '🥈'; rankClass='rank-2'; }}
+                        if (index === 2) {{ rankIcon = '🥉'; rankClass='rank-3'; }}
+                        
+                        return `<tr>
+                            <td class="${{rankClass}}">${{rankIcon}}</td>
+                            <td>${{item.language}}</td>
+                            <td>${{item.mean.toFixed(4)}}</td>
+                            <td>${{relative}}</td>
+                        </tr>`;
+                    }}).join('')}}
+                </tbody>
+            `;
+            section.appendChild(table);
+            
+            container.appendChild(section);
+            
+            // Render Chart
+            new Chart(canvas, {{
+                type: 'bar',
+                data: {{
+                    labels: items.map(i => i.language),
+                    datasets: [{{
+                        label: 'Execution Time (seconds) - Lower is Better',
+                        data: items.map(i => i.mean),
+                        backgroundColor: items.map(i => colors[i.language] || '#cccccc'),
+                        borderColor: '#222',
+                        borderWidth: 1
+                    }}]
+                }},
+                options: {{
+                    responsive: true,
+                    maintainAspectRatio: false,
+                    indexAxis: 'y',
+                    scales: {{
+                        x: {{ beginAtZero: true, title: {{ display: true, text: 'Seconds' }} }}
+                    }}
+                }}
+            }});
+        }}
+    </script>
+</body>
+</html>
+"""
+
+def generate_html_report(results, output_path):
+    report_html = HTML_TEMPLATE.format(
+        date=datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        results_json=json.dumps(results)
+    )
+    
+    with open(output_path, 'w') as f:
+        f.write(report_html)

velocicode/reporter.py

@@ -0,0 +1,79 @@
+from rich import print
+from rich.table import Table
+from rich.console import Console
+
+def print_table(results):
+    if not results:
+        print("[yellow]No results to display[/yellow]")
+        return
+    
+    console = Console()
+    
+    # 1. Group by Benchmark
+    grouped = {}
+    for r in results:
+        bench_name = r['benchmark']
+        if bench_name not in grouped:
+            grouped[bench_name] = []
+        grouped[bench_name].append(r)
+        
+    # 2. Process each group
+    for bench_name, group_results in grouped.items():
+        # Sort by mean time (fastest first)
+        group_results.sort(key=lambda x: x['mean'])
+        
+        # Determine baseline (fastest)
+        if not group_results:
+            continue
+            
+        fastest_time = group_results[0]['mean']
+        
+        # Create Table
+        table = Table(
+            title=f"Benchmark: [bold cyan]{bench_name}[/bold cyan]",
+            show_header=True,
+            header_style="bold white",
+            border_style="blue",
+            expand=True
+        )
+        
+        table.add_column("Rank", style="bold yellow", justify="center", width=4)
+        table.add_column("Language", style="magenta", width=12)
+        table.add_column("Time (s)", justify="right")
+        table.add_column("Relative", justify="right")
+        table.add_column("Min (s)", style="dim", justify="right")
+        table.add_column("Max (s)", style="dim", justify="right")
+
+        for i, r in enumerate(group_results):
+            # Rank
+            rank_display = str(i + 1)
+            if i == 0:
+                rank_display = "🥇"
+            elif i == 1:
+                rank_display = "🥈"
+            elif i == 2:
+                rank_display = "🥉"
+            
+            # Relative Speed
+            rel_speed = r['mean'] / fastest_time
+            rel_str = f"{rel_speed:.2f}x"
+            
+            # Colorize Relative Speed
+            if rel_speed < 1.05:
+                rel_style = "[green]"
+            elif rel_speed < 5.0:
+                rel_style = "[yellow]"
+            else:
+                rel_style = "[red]"
+            
+            table.add_row(
+                rank_display,
+                r['language'],
+                f"{r['mean']:.4f}",
+                f"{rel_style}{rel_str}[/]",
+                f"{r['min']:.4f}",
+                f"{r['max']:.4f}"
+            )
+            
+        console.print(table)
+        console.print("") # Newline between tables

velocicode/runner.py

@@ -0,0 +1,65 @@
+import subprocess
+import time
+import os
+import shutil
+
+class BenchmarkRunner:
+    def __init__(self, config):
+        self.config = config
+
+
+
+    def run_benchmark(self, language, source_path, iterations=5, on_status=None):
+        def log(msg):
+            if on_status:
+                on_status(msg)
+            else:
+                print(msg)
+
+        lang_config = self.config.get('languages', {}).get(language)
+        if not lang_config:
+            raise ValueError(f"Unknown language: {language}")
+
+        # Prepare output binary path if needed
+        bin_dir = os.path.join(os.path.dirname(source_path), 'bin')
+        os.makedirs(bin_dir, exist_ok=True)
+        bin_name = f"runner_{language}"
+        bin_path = os.path.join(bin_dir, bin_name)
+
+        # Compile if necessary
+        try:
+            compile_cmd_tpl = lang_config.get('compile')
+            if compile_cmd_tpl:
+                cmd = compile_cmd_tpl.format(source=source_path, out=bin_path)
+                log(f"Compiling...")
+                subprocess.check_call(cmd, shell=True)
+            else:
+                # No compilation needed
+                pass
+        except subprocess.CalledProcessError as e:
+            log(f"[red]Compilation failed[/red]: {e}")
+            return None
+
+        run_cmd_tpl = lang_config.get('run')
+        # If compiled, use bin_path, else use source_path
+        cmd = run_cmd_tpl.format(source=source_path, out=bin_path)
+
+        times = []
+        for i in range(iterations):
+            log(f"Running iteration {i+1}/{iterations}...")
+            start = time.time()
+            try:
+                subprocess.check_call(cmd, shell=True, stdout=subprocess.DEVNULL)
+                duration = time.time() - start
+                times.append(duration)
+            except subprocess.CalledProcessError as e:
+                log(f"[red]Runtime error[/red]: {e}")
+                return None
+
+        # simple stats
+        return {
+            'mean': sum(times) / len(times),
+            'min': min(times),
+            'max': max(times),
+            'count': len(times)
+        }

velocicode/system_info.py

@@ -0,0 +1,23 @@
+import platform
+import psutil
+import cpuinfo
+
+def get_system_info():
+    """
+    Returns a dictionary containing system information.
+    """
+    cpu_info = cpuinfo.get_cpu_info()
+    cpu_model = cpu_info.get('brand_raw', 'Unknown CPU')
+    arch = platform.machine()
+    
+    ram_bytes = psutil.virtual_memory().total
+    ram_gb = ram_bytes / (1024**3)
+    
+    os_info = f"{platform.system()} {platform.release()}"
+    
+    return {
+        "os": os_info,
+        "cpu": cpu_model,
+        "arch": arch,
+        "ram": f"{ram_gb:.1f} GB"
+    }

velocicode-0.5.0.dist-info/METADATA

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: Velocicode
+Version: 0.5.0
+Summary: A CLI tool for programming language speed benchmarks
+Author-email: Code Agent <agent@example.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyyaml
+Requires-Dist: rich>=13.0.0
+Requires-Dist: psutil
+Requires-Dist: py-cpuinfo
+Dynamic: license-file
+
+# Velocicode 🚀
+
+**Velocicode** is a high-performance command-line tool for benchmarking programming language speeds. It allows you to run standard algorithms across multiple languages and compare their execution time with professional, interactive reports.
+
+## Features ✨
+
+- **Multi-Language Support**: Benchmarks **Python**, **C++**, **Rust**, **Go**, and **JavaScript** (Node.js).
+- **Smart Execution**:
+  - **System Info**: Auto-detects your CPU, RAM, and OS.
+  - **Dependency Check**: Automatically checks for compilers and skips missing languages.
+- **Premium UI**:
+  - Beautiful terminal output using the **Rich** library.
+  - Rankings with Medals (🥇 🥈 🥉).
+  - Relative Speed comparisons (e.g., `1.00x` vs `45.9x`).
+- **Data Export**:
+  - **JSON**: Raw data export for analysis.
+  - **HTML**: Interactive reports with **Charts** for presentations.
+
+## Installation
+
+```bash
+pip install velocicode
+```
+
+## Usage
+
+### 1. Run Benchmarks
+
+Run all benchmarks with default settings:
+
+```bash
+velocicode run
+```
+
+The tool will display your system information and check if you have the necessary compilers. If some are missing, it will ask if you want to proceed with the available ones.
+
+Filter by specific algorithm or language:
+
+```bash
+# Run only Matrix Multiplication in Rust and Go
+velocicode run --filter-algo matrix_mul --filter-lang rust,go
+```
+
+### 2. Generate Reports 📊
+
+Export results to JSON or generate a visual HTML report:
+
+```bash
+velocicode run --html report.html --json results.json
+```
+
+Open `report.html` in your browser to see interactive bar charts!
+
+### 3. Check Compilers
+
+Velocicode relies on system compilers. Check what you have installed:
+
+```bash
+velocicode check
+```
+
+## Requirements
+
+> [!IMPORTANT]
+> This tool requires external compilers. `pip` installs the runner, but you need the languages installed:
+
+- **Python 3.7+**
+- `g++` (for C++)
+- `rustc` (for Rust)
+- `go` (for Go)
+- `node` (for JavaScript)
+
+## License
+
+MIT

velocicode-0.5.0.dist-info/RECORD

@@ -0,0 +1,33 @@
+velocicode/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+velocicode/config.yaml,sha256=-9AMoCq1SsHgbBzDk0DZhnwxGev_hFM1mq_az-teJnw,325
+velocicode/main.py,sha256=YSTF4zhguej2QZg8a-miK0UgLV9Sik2VUCnC57WycCE,8437
+velocicode/report_generator.py,sha256=hXaO6Vf6AxVep4SYlJifeoAYRnWwCjfjSluOb1NxOQQ,5507
+velocicode/reporter.py,sha256=o7byb2SpSF1o6kbr9yhWdLPV3-wem8L6_gY-0DoTz8o,2484
+velocicode/runner.py,sha256=8sUhLJhTCL5wWGZ6IJcaDn4MHdUugxUTINds2LKdFXM,2104
+velocicode/system_info.py,sha256=pUHUr6aRnGeXAprcYgCpLntzhpbLRpU50DXvfWz5Fu4,544
+velocicode/benchmarks/fibonacci/cpp/main.cpp,sha256=fU0cJUofLBHXM6i_d4LA-f8xZoGyLBQvCTFS2mqHrXA,285
+velocicode/benchmarks/fibonacci/go/main.go,sha256=a94v7GVuqpVkGrjFFU6xRXZ4B4zJ-IAbYIG0CRM2pvI,274
+velocicode/benchmarks/fibonacci/javascript/main.js,sha256=A-rTit4G6USJ2FWaxTBC18O41AdCn84kWv9S0R5JIVE,193
+velocicode/benchmarks/fibonacci/python/main.py,sha256=gYD1pC5jKckc1GvqoDpppToPssKn0w7v73LsLo5okF8,203
+velocicode/benchmarks/fibonacci/rust/main.rs,sha256=tXIltVAP4M6mEVGTe5IkFTmWHwZiGReTGpnwwf3PiUY,304
+velocicode/benchmarks/matrix_mul/cpp/main.cpp,sha256=H1wLUuMfsLP1l9qH4igXWFiRnDTfBMck8WHv5TcfTIM,1004
+velocicode/benchmarks/matrix_mul/go/main.go,sha256=_dN1D650fZp7dp0utdpqbwO8UXebmwNnTmDIN76wKR0,737
+velocicode/benchmarks/matrix_mul/javascript/main.js,sha256=_trWvLtlwzme6bLudDkWljPb9teo8GRikv1m7OqWh6k,693
+velocicode/benchmarks/matrix_mul/python/main.py,sha256=j2c9tJaOA5Zn4aB9cPAQvtlOuQOfgHcPyGWAXK9fpPg,590
+velocicode/benchmarks/matrix_mul/rust/main.rs,sha256=IT15ptLggEP_3q_iZ1RBIAs3pPPteZ6ZAvnkogELPOw,827
+velocicode/benchmarks/primes/cpp/main.cpp,sha256=dtBbXZ_Z_grhVV3rW0TX_gYreWW5kaeMB1AFZt2gm-U,558
+velocicode/benchmarks/primes/go/main.go,sha256=PxZFltOWXxqK7XpBPC7tRfLsr502j0-ORlYvj8ZZhNI,519
+velocicode/benchmarks/primes/javascript/main.js,sha256=6ok5TFHOX-P_yemnBTjTDMeHr7BqqsTB9uh92-kNfaA,465
+velocicode/benchmarks/primes/python/main.py,sha256=jhlKq2KDMYnjmVt1eFzgodFFF3EPv1hlGjmHOqHt1x4,470
+velocicode/benchmarks/primes/rust/main.rs,sha256=-fuEJFULB9MHpxGmdc1HlD7lTL9ZOpbEj0HWiRrjWDA,643
+velocicode/benchmarks/quicksort/cpp/main.cpp,sha256=2s1l6zrBJuUjiY_BZnFcN01ow9l4GcyGZzmRwJcSOhE,462
+velocicode/benchmarks/quicksort/go/main.go,sha256=9I8Onqf_tzqoRqDeP-RTp2t47ofYkYbR277-ABF_ias,323
+velocicode/benchmarks/quicksort/javascript/main.js,sha256=wUSfEIb4QIk-r1u5P1aaoKu9n7Rd8FpI1mDpgE1N3WE,246
+velocicode/benchmarks/quicksort/python/main.py,sha256=UBpRHGJ3r32UAYmpwa_8cN8urI1O-VH1Xza-OduP-y0,652
+velocicode/benchmarks/quicksort/rust/main.rs,sha256=30uWtnz8ZkHcfiqMKln_nTHmQcytJ-XtY-TOk0kzZKo,918
+velocicode-0.5.0.dist-info/licenses/LICENSE,sha256=ESYyLizI0WWtxMeS7rGVcX3ivMezm-HOd5WdeOh-9oU,1056
+velocicode-0.5.0.dist-info/METADATA,sha256=Ug1b2roBf3KSWpMN8j-7UDWCvHZ_M3KBAG1vwbeDdnE,2482
+velocicode-0.5.0.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+velocicode-0.5.0.dist-info/entry_points.txt,sha256=OhCJJRwEh3bhmwUpd1oML4Ta-KLX3a9dq7Mu7mNi-pc,52
+velocicode-0.5.0.dist-info/top_level.txt,sha256=zphesZGvGtNa8jw8Bpmx9byQPHk-YnNEWuK7s_hdX0E,11
+velocicode-0.5.0.dist-info/RECORD,,

velocicode-0.5.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

velocicode-0.5.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+velocicode = velocicode.main:main

velocicode-0.5.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

velocicode-0.5.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+velocicode