v2026.03.13.2-alpha

Functional Code.
Imperative Speed.

A statically-typed language where value semantics compile to in-place mutations. No garbage collector. No borrow checker. No compromise.

main.ori
Output

Ori is a statically-typed language where functional code compiles to imperative speed

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.

The Design That Compounds

Value semantics enables safe memory, which enables complete effects, which enables trivial mocking, which makes testing painless. One decision, compounding returns.

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.

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.

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