OriLang

v2026.03.27.5-alpha

Compiles to native binaries — no runtime, no VM
No garbage collector. No borrow checker.
Side effects declared in function signatures
Mocking built into the language

$ curl -fsSL https://ori-lang.com/install.sh | sh

user.ori

// real http — declared, not hidden
@fetch_user (id: int) -> Result<User, Error>
    uses Http = {
    let resp = Http.get(url: `/users/{id}`)?;
    resp.json() as? User
}

// test it — swap the capability, no frameworks
@test_fetch_user tests @fetch_user () -> void = {
    let mock_api = handler(state: ()) {
        get: (s, url:) -> (s, Response.json(
            body: { "name": "Ori", "id": 1 }
        ))
    };

    with Http = mock_api in {
        let user = fetch_user(id: 1).unwrap();
        assert_eq(actual: user.name, expected: "Ori");
    }
}

Core principles

A compiled language where functional code runs at native speed

Compiles to Native Executables

Write your code, compile it, ship a single binary. Ori produces standalone executables for Windows, Linux, and macOS — your users don't need Ori installed. No runtime, no VM, no interpreter required.

The Memory Model Nobody Else Has

No garbage collector. No borrow checker. No manual allocation. Eight stacked optimizations turn functional code into in-place mutations — zero compromise between safety and speed.

Effects You Can See

Side effects are explicit. Every function declares its capabilities. Mocking is built-in — just provide a different implementation with `with...in`. No frameworks. No DI containers.

Smart Testing

Tests live in the dependency graph. Change a function, and every affected test runs automatically. Your tests even make your binary faster — they're automatic profiling data for the optimizer.

Architecture

The Design That Compounds

Not independent features bolted together — one design choice with compounding returns.

Value Semantics

Every variable owns its data. No shared mutation. No aliasing.

Safe Memory

No aliasing lets ARC optimize: in-place reuse, borrow inference, copy-on-write — all automatic.

Complete Effects

No hidden mutation means capabilities see every side effect. Nothing escapes.

Trivial Mocking

Capabilities are injectable. Replace any effect with `with...in`. No frameworks needed.

Safe Refactoring

Smart testing + dependency tracking = change with confidence. Tests that know your code.

Quick start

Get Started

1 Install

curl -fsSL https://ori-lang.com/install.sh | sh

2 Write your first program

// hello.ori
@main () -> void = {
    print(msg: "Hello, World!");
}

3 Run it

ori run hello.ori

4 Compile a native binary

ori build hello.ori -o hello
./hello   # standalone executable — no Ori needed

Read the full documentation

From the team

Other projects

Built by the same team behind Ori Lang