JavaScript's Soul.
Rust's Speed.
A compiled, type-safe language with native performance and a modern toolchain. Small, honest core. No VM, no GC, no compromise.
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 from scratch for the next era of software -- fast today, with a small core the authors are willing to freeze.
Native Speed
Compiles to machine code via Cranelift. No interpreter, no VM. Within ~1.3x of C and Rust on simple CPU microbenchmarks.
Type Safety
Generics, traits, pattern matching, Result and Optional types. Catch bugs at compile time, not in production.
Small, Honest Core
Turbo keeps the compiler focused on a general-purpose, compiled language. Framework-shaped features (agents, GPU kernels, distributed actors) live in sidecar libraries, not keywords — so the core stays stable.
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.
Zero GC
No garbage collector pauses. Deterministic memory management with ~93 KB binaries. Deploy anywhere with no runtime.
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
Best of 5 wall-clock runs on an Apple M5 Max (macOS 26.5.1, 2026-06-27). Every baseline runs the same algorithm over the same input and the harnesses enforce byte-for-byte identical output — honest numbers, not best-case marketing. Run them yourself with the benchmark scripts in turbo/benchmarks.
fib(40) — recursion microbenchmark
Pure function-call overhead. Turbo's native build lands within ~1.3x of C and Rust, in the same range as Go, and far ahead of interpreted runtimes.
word-count — real-world workload
Read a ~5 MB file (1.05M words), tokenize, count frequencies in a hashmap, print the top 20 — file I/O, strings, hashmaps, sorting. On this string/hashmap-heavy work Turbo's native build is about 1.4x slower than C, down from ~2.2x: int values now live inline in the hashmap entry, so the counter loop no longer re-stringifies, re-parses, or re-allocates on every increment. Real, reproducible numbers.
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. Native speed, modern syntax, and a roadmap that stays honest about what's shipped.