🚀 vibe-code – Brain-Dead Simple Parallelism for Rust

For coders who just want things to work fast.

vibe-code is a dead-simple parallel execution engine for Rust that runs your functions on all CPU cores — with no threads, no channels, and no async boilerplate.

Inspired by nature’s circulatory systems — from ants to whales — where the design is identical, only the scale changes. Your code should scale the same way.

✨ What Can You Do?

• Run heavy calculations in parallel – compress files, process images, crunch numbers.
• Process large batches of data – without your computer exploding.
• Make your code ridiculously fast – with minimal changes.

🎯 Dead Simple Examples

Basic Parallel Work

use vibe_code::VibeSystem;

let system = VibeSystem::new();

let job1 = system.run(compress_file, my_big_file);
let job2 = system.run(process_image, my_photo);
let job3 = system.run(calculate_stuff, my_data);

println!("Jobs running in background...");

let compressed = job1.get();
let processed = job2.get(); 
let result = job3.get();

Batch Processing

let jobs = vec![
    system.run(process_chunk, chunk1),
    system.run(process_chunk, chunk2),
    system.run(process_chunk, chunk3),
    system.run(process_chunk, chunk4),
    system.run(process_chunk, chunk5),
];

let results = vibe_code::collect(jobs);
println!("Processed {} items", results.len());

🎮 Real Examples

Video Processing

let system = VibeSystem::new();

let frame_jobs: Vec<_> = video_frames
    .into_iter()
    .map(|frame| system.run(apply_filter, frame))
    .collect();

let filtered_frames = vibe_code::collect(frame_jobs);

Web Scraping

let system = VibeSystem::new();

let jobs = vec![
    system.run(scrape_website, "https://site1.com"),
    system.run(scrape_website, "https://site2.com"),
    system.run(scrape_website, "https://site3.com"),
];

let scraped_data = vibe_code::collect(jobs);

File Compression

let system = VibeSystem::new();

for file in big_files {
    let job = system.run(compress_file, file);
    // Fire and forget
}

Speed Comparison

use std::{thread, time::Duration, time::Instant};
use vibe_code::{VibeSystem, collect};

fn process_data(id: i32) -> String {
    thread::sleep(Duration::from_millis(500));
    format!("Processed #{}", id)
}

let system = VibeSystem::new();

let start_time = Instant::now();

let jobs: Vec<_> = (0..10)
    .map(|i| system.run(process_data, i))
    .collect();

println!("🚀 All 10 jobs submitted instantly.");

let results = collect(jobs);

let duration = start_time.elapsed();
println!("📦 All jobs finished!");
println!("⏱️  Time taken: {:?}. (Much faster than the sequential 5 seconds!)", duration);

🔧 Setup

Add to your Cargo.toml:

[dependencies]
vibe-code = "0.1.0"

Then use it:

use vibe_code::{VibeSystem, collect};

That's it. No config. No setup hell.

📚 API Reference

VibeSystem

• VibeSystem::new() – Creates a new system.
• system.run(my_func, data) – Runs a function with input data in parallel.
• system.go(my_func) – Runs a function with no input.

Job

• job.get() – Waits for the job to finish and returns the result.
• job.peek() – Checks if done without blocking. Returns Some(result) or None.
• job.is_done() – Returns true if the job is complete.

Utilities

• collect(jobs) – Waits for Vec<Job<T>> to finish and returns Vec<T>.

🚨 Error Handling

This library is intentionally crash-first.

If a function in one of your jobs panics, your whole program will crash — loudly — with a helpful message. That’s on purpose.

• ❌ Your job failed! Check your function for bugs.
• ❌ Job was cancelled - did you shut down the system?

No silent failures. No mysterious bugs. Fail fast. Fix fast.

🤔 When NOT to Use This

• For quick scripts – Just run code normally.
• For a single small operation – No point parallelizing one thing.
• If you need complex error handling – vibe_code crashes on failure by design.

💡 Philosophy

This library follows the "vibe coder" philosophy:

• ✅ It just works – no setup hell.
• ✅ Fast by default – uses all your CPU cores out of the box.
• ✅ Crash early – better than bugs hiding in shadows.
• ✅ Zero learning curve – if you can call a function, you can use this.

No threads. No channels. No async spaghetti. Just results.

⚡ Performance Snapshot

Processing 10 jobs (500ms each):

• Sequential: ~5 seconds
• With vibe_code: ~0.6 seconds

Tested on 12-core CPU.

🎯 Bottom Line

Your slow, sequential code:

for item in big_list {
    process(item);  // Slow, one at a time
}

Becomes this:

let jobs: Vec<_> = big_list
    .into_iter()
    .map(|item| system.run(process, item))
    .collect();

let results = collect(jobs);  // Fast, all at once

Same logic. Way faster. Zero complexity. That’s the vibe. 🚀

Inspired by biology: ants and whales use the same circulatory system — just scaled. vibe_code works the same way.