Active Development

The fun way to solve
hard problems

Systems-level power with none of the ceremony. Memory safety, green threads, and a type system that stays out of your way — so you can focus on what matters.

Start the Tour Read the Docs
main.run 
pub type Point struct {
    x f64
    y f64
}

fun (p @Point) length() f64 {
    return math.sqrt(p.x * p.x + p.y * p.y)
}

fun (p &Point) translate(dx f64, dy f64) {
    p.x = p.x + dx
    p.y = p.y + dy
}

pub fun main() !void {
    p := Point{ x: 3.0, y: 4.0 }
    p.translate(1.0, -1.0)

    content := try read_file("config.txt") :: "loading config"
    fmt.println(content)
}

Why Run?

Powerful tools, none of the complexity.

Memory Safety

Generational references catch use-after-free at runtime. No GC pauses, no borrow checker complexity.

Green Threads

Lightweight concurrency with `run`. Spawn thousands of tasks scheduled across OS threads.

Error Unions

Errors are values. Propagate with `try`, attach context with `::`, match with `switch`.

Sum Types

First-class algebraic types with exhaustive pattern matching via `switch`.

No Generics

Built-in collections have language-level support. Simple type system, clear error messages.

Deterministic Destruction

Owning references auto-free on scope exit. Predictable, zero-overhead resource cleanup.

See it in action

Clean syntax, powerful features, zero ceremony.

server.run
package main
use "fmt"
use "time"
fun say(msg: string) {
    for i in 0..3 {
        time.sleep(100)
        fmt.println(msg)
    }
}
pub fun main() {
    run say("hello")
    say("world")
}

How Run compares

The sweet spot between simplicity and control.

Memory Safety

Run

Generational refs

Go

Garbage collector

Rust

Borrow checker

Zig

Manual

Concurrency

Run

Green threads

Go

Goroutines

Rust

async / Tokio

Zig

async

Generics

Run

None (built-in collections)

Go

Yes

Rust

Yes

Zig

Comptime

Error Handling

Run

Error unions + context

Go

Multiple returns

Rust

Result<T, E>

Zig

Error unions

Learning Curve

Run

Low

Go

Low

Rust

High

Zig

Medium

Get started

Install Run in seconds on macOS, Linux, or build from source.

# Homebrew
$ brew install marsolab/tap/run

# Or via install script
$ curl -fsSL https://runlang.dev/install.sh | sh
# Install script
$ curl -fsSL https://runlang.dev/install.sh | sh

# Or via apt (Debian/Ubuntu)
$ sudo dpkg -i run_<version>_amd64.deb
$ git clone https://github.com/marsolab/runlang.git
$ cd runlang
$ zig build
$ zig build run -- run hello.run
Hello, World!

Requires Zig 0.15 or later.

Compiler status

Run is in active development. Here's where we stand.

Lexer Complete
Parser Complete
Name Resolution Complete
Type Checking In Progress
IR Lowering Complete
C Code Generation Complete
Runtime Library MVP
Standard Library Not Started

This is a great time to get involved.