Safe. Fast. Easy to read.
A programming language for software you can rely on.

People and AI

When people and AI write code together

More and more code is written with a model, or by an agent that changes a program on its own. Such code reads well, and its mistakes are often the kind review finds hardest: two tasks that change the same value, an error that nobody handles, a call outside what a function expects. Nikaia's compiler looks for these before the program runs, and where it cannot tell what a call touches, as in a Rust crate or a C library, it says so instead of refusing.

Its messages say what is wrong and what to write instead, so an agent can read the error, change the code and build again, and the person reviews a program the compiler has already checked. No model has Nikaia in its training data yet: generating it means putting the specification in the model's context. The compiler is pre-alpha. The longer argument →

Very safe

Catch mistakes before they become failures.

Many bugs follow patterns. Nikaia checks for those patterns before they reach your users, and says where it cannot.

overlap {
    balance = balance + 50
    balance = balance - 30
}

error[NK2104]: These two branches can't run at the same time.
note: Both change `balance`.

a.update fn(mut acc) {
    acc.balance -= 30
    time::sleep(5.millis())
}

error: `time::sleep` can pause, but you're holding a lock here.

fn load() -> String {
    return fs::read_to_string("config.txt", fs::Root::Anywhere)
}

error: This function can fail, because `fs::read_to_string` can fail.

fn percent(n: int) -> int {
    assert(n >= 0 && n <= 100)
    return n
}

percent(140)

error: This call breaks `percent`'s precondition `n >= 0 && n <= 100` every time it is reached.

Easy to understand

Short code that reads like a script.

You write what should happen, and Nikaia works out the technical details other fast languages make you spell out. When something is wrong, it tells you in plain words what to change.

let user = async db::load_user(id)
let rights = async db::load_rights(id)
let prefs = cache::load_prefs(id)
render(user, rights, prefs)   // waits for both

error[NK1139]: You're changing `count`, but it wasn't declared as mutable.
help: Add `mut` where it's declared: `let mut count`.

grammar Calc {
    entry rule expr -> i64 =
        head:term tail:add_tail* { … }

    rule add_tail -> i64 =
          "+" t:term { t }
        | "-" t:term { -t }
}

Where Nikaia fits