v0.1.0-alpha · Open Source · Systems Language

Control everything. Compromise nothing.

Kairo is a modern systems programming language. The raw power of C++. The ergonomics of modern design. Zero compromises on performance.

COMPILER ALPHA | SELF-HOSTING IN PROGRESS | C++ BOOTSTRAP

Get Started View on GitHub

dot_product.kairo kairo

import std::Parallel;

fn <T: Numeric> dot(a: [T], b: [T]) -> T! {
    if a.len() != b.len() {
        return error("Length mismatch");
    }
    return Parallel::zip(a, b)
        .map(|(x, y)| x * y)
        .sum();
}

fn main() {
    let a = [1.0, 2.0, 3.0];
    let b = [4.0, 5.0, 6.0];
    let result = dot(a, b)!;
    print(f"Dot product: {result}");
}

Features

Built for the demanding.
Not the comfortable.

Zero-cost Abstractions

Write clean, expressive code that compiles to exactly what you'd hand-write in assembly. No hidden overhead, no runtime cost.

Memory Control

Manual memory management with optional borrow checking. Raw pointers when you need them. Smart pointers when you don't.

C/C++ Interop

First-class FFI. Call C and C++ code directly. Bit-level ABI compatibility. No wrappers, no overhead, no ceremony.

Blazing Performance

Predictable performance. No background GC. No hidden allocations. You control every nanosecond of execution.

Modern Ergonomics

Generics, interfaces, lambdas, pattern matching. All the tools you expect — none of the runtime cost. Expressive by design.

Built-in Tooling

Formatter, linter, package manager, LSP — all ship with the compiler. One toolchain, zero config, maximum productivity.

Code

See it in action. Clean syntax.
No magic.

    
hello.kairokairo
 fn main() {
    // Variables are immutable by default
    let name = "Kairo";
    let mut count: i32 = 0;

    // f-strings for string interpolation
    for i in 0..3 {
        print(f"[{i}] Hello from {name}!");
        count += 1;
    }

    print(f"Ran {count} times.");
} 

    
memory.kairokairo
 // Kairo's ownership model prevents use-after-free
struct Buffer {
    data: *mut u8,
    len:  usize,
}

impl Buffer {
    fn new(size: usize) -> Buffer {
        return Buffer {
            data: alloc(size),
            len: size,
        };
    }

    fn ~Buffer() {  // destructor
        free(self.data);
    }
}

fn main() {
    let buf = Buffer::new(1024);
    // buf freed automatically here
} 

    
ffi.kairokairo
 // Direct C/C++ interop — zero overhead
extern "C" {
    fn printf(fmt: *const char, ...) -> i32;
    fn malloc(size: usize) -> *mut void;
    fn free(ptr: *mut void);
}

// Link against C++ libraries
@link("stdc++")
extern "C++" {
    class std::vector<T>;
}

fn main() {
    // Call C directly — no wrapping
    unsafe {
        printf(c"Hello from C: %d\n", 42);
    }
} 

Install

Get Kairo in
seconds.

One command gets you the compiler, formatter, LSP, and package manager. No separate installs, no configuration.

Alpha Notice

The compiler is currently in alpha. Written in C++, being rewritten in Kairo itself. APIs may change.

Full Install Guide

Quick install

$ curl -fsSL https://kairolang.org/install.sh | bash

From source

$ git clone https://github.com/kairolang/kairo-lang.git && cd kairo-lang && xmake build -j8

PowerShell

$ irm https://kairolang.org/install.ps1 | iex

From source

$ git clone https://github.com/kairolang/kairo-lang.git cd kairo-lang && xmake build -j8

Clone

$ git clone https://github.com/kairolang/kairo-lang.git

Build

$ cd kairo-lang && xmake build -j8 -v

Test

$ xmake run tests

SYS::READY —— KAIRO v0.1.0-alpha —— KSF OPEN SOURCE

Get Started

Ready to build
the future?

Join the small but growing community of systems programmers who refuse to compromise on performance or ergonomics.

Start with Docs Join on GitHub

Control everything. Compromise nothing.

Built for the demanding. Not the comfortable.