Familiar code.
Native execution.
A path to deeper control.
Turbo is a compiled, type-safe language for people who like TypeScript and JavaScript ergonomics and want native compilation today, with deeper performance and memory controls on the roadmap.
fn fib(n: i64) -> i64 {
if n <= 1 { n }
else { fib(n - 1) + fib(n - 2) }
}
fn main() {
let result = fib(40)
print("fib(40) = {result}")
}Best first proof
Start with the web-dashboard demo
The clearest runnable example today is examples/web-dashboard/main.tb. It serves a styled browser UI and five JSON benchmark endpoints from one Turbo file.
Quickstart
turbolang run examples/web-dashboard/main.tb
# then open http://localhost:3000- • Browser UI plus JSON endpoints in one process
- • Good first demo for people evaluating Turbo quickly
- • Ships today — no roadmap syntax required
Why Turbo?
A language designed around progressive disclosure: readable syntax first, native execution underneath, deeper control only when the program needs it.
Native Execution
Compiles to machine code through Cranelift for JIT development and AOT binaries. The current focus is closing measured gaps against Rust with reproducible workloads.
Type Safety
Generics, traits, pattern matching, Result and Optional types. Catch bugs at compile time, not in production.
Small, Honest Core
Turbo is strongest today as a general-purpose native language for CLIs, tools, small services, and compute workers. GUI, game, embedded, and OS-level work remain gated by explicit runtime and library milestones.
Thread Concurrency
spawn runs work on real OS threads; await joins them. Plus channels and mutex — straightforward concurrency with no event loop and no hidden runtime.
Progressive Control
The shipped model avoids a tracing GC and uses owned values, ARC, and copy-on-write. The roadmap adds cost attribution, borrowed views, owned buffers, and no-allocation regions for Rust-class control where it matters.
Great DX
Built-in test runner, formatter, REPL, LSP server, and VS Code extension. Everything works out of the box.
Expressive by Default
Pattern matching, thread concurrency, and HTTP+JSON servers -- all with clean, readable syntax.
type Shape {
Circle(f64)
Rectangle(f64, f64)
Triangle(f64, f64)
}
fn area(shape: Shape) -> f64 {
match shape {
Circle(r) => 3.14159 * r * r
Rectangle(w, h) => w * h
Triangle(b, h) => 0.5 * b * h
}
}
fn main() {
let s = Shape.Circle(5.0)
print("Area: {area(s)}")
}Performance status
The current committed baseline is intentionally diagnostic: paired runs, warmups, randomized order, bootstrap intervals, and output-oracle checks on Apple M5 Max / macOS 26.5.1. It is not yet a Rust-parity claim. Raw evidence lives in benchmarks/results/g2-initial-20260906.
fib(40) — recursion microbenchmark
Pure function-call and recursion overhead. Turbo AOT median wall time was 233.31ms vs Rust at 161.09ms, with a paired elapsed ratio of 1.444× and a 95% interval of 1.4325–1.4618.
word-count — real-world workload
Read a ~5 MB file, tokenize, count frequencies in a hashmap, and print top words. Output equivalence is proven, but the implementation shapes are not identical, so this is an application diagnostic rather than a CPU parity result. Turbo AOT median wall time was 88.62ms vs Rust at 22.64ms, paired ratio 3.871×.
Get Started in Seconds
Clone, build, run. Or install via Homebrew.
Homebrew
brew tap ZVN-DEV/turbo
brew install turbo-lang
turbolang run hello.tbFrom Source
git clone https://github.com/ZVN-DEV/Turbo-Language.git
cd Turbo-Language
cargo build --release -p turbo-cli --manifest-path turbo/Cargo.toml
./target/release/turbolang run hello.tbReady to build?
Start writing Turbo today. Familiar syntax, native binaries, and a roadmap that says plainly what is shipped, what is measured, and what still has to earn its claim.