Pre-Alpha

Code That Proves Itself

A general-purpose language with strict static typing, mandatory testing, and dependency-aware integrity. If it compiles, it has tests. If it has tests, they pass. If you change it, you'll know what broke.

See It In Action

Try Ori right in your browser. Write code, click Run, see results instantly.

main.ori
Output

The Four Pillars

Mandatory Verification

Every function requires tests or it doesn't compile. Contracts enforce invariants. The compiler refuses to produce code it can't verify.

Dependency-Aware Integrity

Tests live in the dependency graph. Change a function and its tests run. Change a function and callers' tests run too. Fast feedback on what matters.

Explicit Effects

Capabilities declare what a function can do. No hidden side effects. Mocking is trivial. Tests are fast because everything is injectable.

ARC-Safe by Design

Memory managed via ARC. No tracing GC, no borrow checker. Closures capture by value. No shared mutable references. Value semantics by default.

The Virtuous Cycle

Each design decision reinforces the next, creating a system where verification is practical, not painful.

1
Capabilities
declare effects explicitly
2
Easy Mocking
inject test doubles trivially
3
Fast Tests
no real I/O in tests
4
Dep-Aware Testing
only run what changed
5
Mandatory Tests
every function verified
6
Code Integrity
if it compiles, it works

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