The Centauri Language

// hello.cnt — the smallest complete Centauri program.
// A `system` is the program container; `launch()` is the entry point.
system Main {
    launch() {
        transmit("hello, Centauri")   // transmit() prints a value + newline
    }
}

Centauri launch  <file.cnt>            # Interpret and run immediately
Centauri compile <file.cnt> [output]   # Compile to a standalone native binary

# Run a script directly while you iterate
Centauri launch examples/bounce.cnt

# Produce a distributable binary called "bounce"
Centauri compile examples/bounce.cnt bounce
./bounce            # runs with no interpreter installed

chamber "stdlib/math"          // (1) imports come first

// (2) top-level helper functions — visible to everything below
fn greet(name) {
    return "Greetings, " + name + "!"
}

// (3) a class
capsule Crew {
    name
    role
    badge() { return self.name + " — " + self.role }
}

// (4) the program container; execution starts in launch()
system Main {
    launch() {
        transmit(greet("Centauri"))             // Greetings, Centauri!
        captain = Crew { name: "Ada", role: "Pilot" }
        transmit(captain.badge())               // Ada — Pilot
    }
}

system Main {
    launch() {
        // Float — the sole numeric type (integers are just floats)
        age = 42
        pi  = 3.14159
        transmit(age)            // 42
        transmit(age / 8)        // 5.25  (no integer division surprises)

        // String — UTF-8 text, concatenated with +
        name = "Centauri"
        transmit("Hello, " + name)

        // Boolean
        ready = true
        transmit(ready)          // true

        // Vacuum — the explicit "nothing" value
        nothing = Vacuum
        transmit(nothing)        // Vacuum

        // List — ordered and growable
        crew = ["Ada", "Alan", "Grace"]
        transmit(crew)           // [Ada, Alan, Grace]
        transmit(crew[0])        // Ada

        // Closure — a function stored in a variable
        inc = fn(x) { return x + 1 }
        transmit(inc(9))         // 10
    }
}

system Main {
    launch() {
        // Falsy values: false, 0, Vacuum
        if (0)      { transmit("never") } else { transmit("0 is falsy") }
        if (Vacuum) { transmit("never") } else { transmit("Vacuum is falsy") }

        // Truthy values: every other number, all strings, all lists
        if ("")  { transmit("empty string is TRUTHY") }   // prints!
        if ([])  { transmit("empty list is TRUTHY") }     // prints!
        if (-1)  { transmit("any nonzero number is truthy") }
    }
}

system Main {
    launch() {
        transmit(3 + 4 * 2)        // 11  — * binds tighter than +
        transmit(17 % 5)           // 2   — modulo
        transmit(-8)               // -8  — unary negation
        transmit(7 / 2)            // 3.5 — true division, always

        // + is overloaded: it concatenates strings AND lists (Phase 8)
        transmit("foo" + "bar")    // foobar
        transmit([1, 2] + [3, 4])  // [1, 2, 3, 4]
    }
}

system Main {
    launch() {
        transmit(10 >= 10)        // true
        transmit(3 != 4)          // true
        transmit("a" == "a")      // true  — == spans every type
        transmit(Vacuum == 0)     // false — different value kinds
    }
}

fn fetch() {
    transmit("...fetching from network...")   // side effect we want to skip
    return true
}

system Main {
    launch() {
        x = 5
        done = false

        // both forms are equivalent; pick whichever reads better
        if (x > 0 and not done) { transmit("go") }       // go
        if (x > 0 && !done)     { transmit("go (alias)") } // go (alias)

        // short-circuit: because `cached` is true, fetch() never runs
        cached = true
        if (cached or fetch()) { transmit("have data") }  // have data
    }
}

or  <  and  <  not  <  comparison  <  + -  <  * / %  <  unary

system Main {
    launch() {
        count = 0          // creates the variable
        count = count + 1  // re-binds it

        point = Point { x: 0, y: 0 }
        point.x = 10       // sets a capsule field
        transmit(point.x)  // 10
    }
}

capsule Point { x  y }

fn grade(score) {
    if (score >= 90) {
        return "A"
    } else if (score >= 80) {     // chained branch (Phase 9)
        return "B"
    } else if (score >= 70) {
        return "C"
    } else {
        return "try again"
    }
}

system Main {
    launch() {
        transmit(grade(95))   // A
        transmit(grade(83))   // B
        transmit(grade(50))   // try again
    }
}

system Main {
    launch() {
        // countdown from 5 to 1
        n = 5
        orbit (n > 0) {
            transmit(n)
            n = n - 1
        }
        transmit("liftoff!")

        // orbit also drives event/render loops (see Graphics)
        // orbit (gfx.is_open()) { ...draw a frame... }
    }
}

system Main {
    launch() {
        // iterate a list directly
        for item in [10, 20, 30] {
            transmit(item)                  // 10, 20, 30
        }

        // counted loop with range(n) -> 0,1,2,3,4
        for i in range(5) {
            transmit("step " + str(i))
        }

        // iterate the characters of a string
        for ch in "abc" {
            transmit(ch)                    // a, b, c
        }
    }
}

system Main {
    launch() {
        // stop as soon as we reach 5
        for i in range(100) {
            if (i == 5) { clip }    // break out of the loop
            transmit(i)             // 0, 1, 2, 3, 4
        }
    }
}

fn double(x) { return x * 2 }

fn classify(n) {
    if (n < 0) { return "negative" }   // early return
    if (n == 0) { return "zero" }
    return "positive"
}

system Main {
    launch() {
        transmit(double(21))      // 42
        transmit(classify(-3))    // negative
    }
}

capsule Dog { name }

fn describe(value) {
    match value {
        0        => { return "the number zero" }      // numeric literal
        "hi"     => { return "a greeting" }           // string literal
        Vacuum   => { return "nothing at all" }       // the Vacuum pattern
        Dog      => { return "it's a dog" }           // capsule TYPE match
        other    => { return "bound to: " + str(other) } // binding (lowercase)
        _        => { return "fallthrough" }          // wildcard
    }
}

system Main {
    launch() {
        transmit(describe(0))                  // the number zero
        transmit(describe("hi"))               // a greeting
        transmit(describe(Dog { name: "Rex"})) // it's a dog
        transmit(describe(99))                 // bound to: 99
    }
}

fn risky(n) {
    if (n < 0) { jettison "negative input!" }   // throw with a payload
    return n * 2
}

system Main {
    launch() {
        // 1) catching a manual jettison
        explore {
            transmit(risky(10))     // 20
            transmit(risky(-1))     // jettisons here
            transmit("unreached")
        } divert(err) {
            transmit("caught: " + err)   // caught: negative input!
        }

        // 2) runtime faults are catchable too — e.g. divide by zero
        explore {
            transmit(10 / 0)
        } divert(e) {
            transmit("math fault: " + str(e))
        }
    }
}

fn square(x) {
    return x * x
}

fn factorial(n) {
    if (n <= 1) { return 1 }
    return n * factorial(n - 1)     // self-recursion is always allowed
}

system Main {
    launch() {
        transmit(square(9))      // 81
        transmit(factorial(5))   // 120
    }
}

system Main {
    helper(x) { return x + 1 }     // a system function

    launch() {
        transmit(helper(41))       // 42
    }
}

fn make_adder(base) {
    // the returned closure captures `base`
    return fn(x) { return x + base }
}

system Main {
    launch() {
        // 1) a closure capturing an outer variable
        base = 100
        add = fn(x) { return x + base }
        transmit(add(5))          // 105

        // 2) closures as return values — a function factory
        add10 = make_adder(10)
        add50 = make_adder(50)
        transmit(add10(1))        // 11
        transmit(add50(1))        // 51

        // 3) closures as arguments (see map/filter/reduce later)
        nums = [1, 2, 3]
        transmit(nums.map(fn(n) { return n * n }))   // [1, 4, 9]
    }
}

system Main {
    launch() {
        // transmit — prints anything, including structured values
        transmit([1, 2, 3])            // [1, 2, 3]

        // len — works on lists and strings
        transmit(len("Centauri"))      // 8
        transmit(len([10, 20, 30]))    // 3

        // str — convert and concatenate
        transmit(str(42) + "!")        // 42!

        // range — three forms
        transmit(range(5))             // [0, 1, 2, 3, 4]
        transmit(range(2, 6))          // [2, 3, 4, 5]
        transmit(range(0, 10, 2))      // [0, 2, 4, 6, 8]

        // push / pop — grow and shrink a list in place
        xs = [1, 2, 3]
        push(xs, 4)                    // xs is now [1, 2, 3, 4]
        last = pop(xs)                 // last == 4, xs == [1, 2, 3]
        transmit(last)                 // 4
        transmit(len(xs))              // 3
    }
}

// Define your own len(); it wins over the built-in.
fn len(x) { return "I refuse to count" }

system Main {
    launch() {
        transmit(len([1, 2, 3]))   // I refuse to count
    }
}

capsule Animal {
    name                                         // a field
    speak() { return "..." }                     // a method
    describe() {
        return self.name + " says " + self.speak()  // self = the receiver
    }
}

capsule Dog extends Animal {                     // single inheritance
    speak() { return "woof" }                    // overrides Animal.speak
}

system Main {
    launch() {
        // Construct with `ClassName { field: value, ... }`
        d = Dog { name: "Rex" }
        transmit(d.describe())     // Rex says woof
    }
}

capsule Ship {
    name
    status() { return "Ship " + self.name }
}

capsule Cruiser extends Ship {
    guns
    status() {
        // call the parent, then add to it
        return super.status() + " [armed: " + str(self.guns) + "]"
    }
}

system Main {
    launch() {
        c = Cruiser { name: "Aurora", guns: 8 }
        transmit(c.status())   // Ship Aurora [armed: 8]
    }
}

capsule Counter {
    value
    bump()  { self.value = self.value + 1  return self.value }
    reset() { self.value = 0 }
}

system Main {
    launch() {
        c = Counter { value: 0 }
        transmit(c.bump())    // 1
        transmit(c.bump())    // 2
        c.reset()
        transmit(c.value)     // 0
    }
}

system Main {
    launch() {
        d = {"name": "Rex", "age": 3}

        transmit(d["name"])      // Rex     — index to read
        d["age"] = 4             // indexed assignment (existing key)
        d["breed"] = "collie"    // indexed assignment (new key)
        transmit(d["age"])       // 4
        transmit(len(d))         // 3       — number of entries
    }
}

system Main {
    launch() {
        scores = {"ada": 91, "alan": 85, "grace": 99}

        transmit(scores.has("ada"))     // true
        transmit(scores.get("alan"))    // 85
        transmit(scores.keys())         // [ada, alan, grace]  (sorted)
        transmit(scores.values())       // [91, 85, 99]        (by sorted key)

        scores.remove("alan")
        transmit(scores.keys())         // [ada, grace]

        // iterate a dictionary via its keys
        for k in scores.keys() {
            transmit(k + " -> " + str(scores[k]))
        }
    }
}

system Main {
    launch() {
        transmit("Hello".upper())                  // HELLO
        transmit("  spaced  ".trim())              // spaced
        transmit("starship".contains("ship"))      // true
        transmit("file.cnt".ends_with(".cnt"))     // true
        transmit("a-b-a".replace("a", "X"))        // X-b-X
        transmit("ab".repeat(3))                   // ababab
        transmit("42".to_number() + 8)             // 50  (now a number)

        // split + chain
        transmit("a,b,c".split(",").join(" | "))   // a | b | c
    }
}

system Main {
    launch() {
        xs = [3, 1, 2]
        xs.sort()
        transmit(xs)                       // [1, 2, 3]
        transmit(xs.reverse())             // [3, 2, 1]
        transmit(xs.contains(2))           // true
        transmit(xs.index_of(3))           // 0   (after sort)

        // slice(a, b) — half-open range
        transmit([10, 20, 30, 40].slice(1, 3))   // [20, 30]

        // join turns a list into a string
        transmit(["a", "b", "c"].join("-"))      // a-b-c
    }
}

system Main {
    launch() {
        nums = [1, 2, 3, 4, 5]

        // map — transform each element
        doubled = nums.map(fn(x) { return x * 2 })
        transmit(doubled)                  // [2, 4, 6, 8, 10]

        // filter — keep elements that pass the predicate
        evens = nums.filter(fn(x) { return x % 2 == 0 })
        transmit(evens)                    // [2, 4]

        // reduce — fold to a single value (acc starts at 0)
        total = nums.reduce(fn(acc, x) { return acc + x }, 0)
        transmit(total)                    // 15
    }
}

system Main {
    launch() {
        // square each of 1..5, then keep the ones greater than 5
        result = range(1, 6)
            .map(fn(x) { return x * x })          // [1, 4, 9, 16, 25]
            .filter(fn(x) { return x > 5 })       // [9, 16, 25]
        transmit(result)                          // [9, 16, 25]

        // real-world flavour: clean a CSV of names
        names = "ada,alan,grace"
            .split(",")
            .map(fn(n) { return n.upper() })      // ["ADA", "ALAN", "GRACE"]
        transmit(names.join(" | "))               // ADA | ALAN | GRACE
    }
}

system Main {
    launch() {
        transmit(math.sqrt(144))     // 12
        transmit(math.pow(2, 10))    // 1024
        transmit(math.floor(3.9))    // 3
        transmit(math.ceil(3.1))     // 4

        // the common ones work without the math. prefix
        transmit(abs(-9))            // 9
        transmit(max(3, 7))          // 7
        transmit(min(3, 7))          // 3

        // random() returns 0.0 <= r < 1.0
        r = math.random()
        transmit(r >= 0 and r < 1)   // true

        // trig — handy for graphics (angles in radians)
        transmit(math.sin(0))        // 0
        transmit(math.cos(0))        // 1
    }
}

fn distance(x1, y1, x2, y2) {
    dx = x2 - x1
    dy = y2 - y1
    return math.sqrt(dx * dx + dy * dy)
}

system Main {
    launch() {
        transmit(distance(0, 0, 3, 4))   // 5   — classic 3-4-5 triangle
    }
}

chamber "stdlib/math"      // string path, relative to this file
chamber stdlib.math        // dotted form → stdlib/math
chamber "utils" as u       // optional alias

system Main {
    launch() {
        // functions from the imported files are now callable
        transmit("modules loaded")
    }
}

fn worker(start) {
    msg = receive               // block until a message arrives
    transmit("worker got: " + msg)
}

system Main {
    launch() {
        pid = spawn worker(42)  // start `worker` as a new actor → yields a PID
        send "ping" to pid      // enqueue a message to that actor
    }
}

fn heavy(x) { return x * x }

system Main {
    launch() {
        transmit("cores: " + str(proc.cpu_count()))

        // parallel_map runs `heavy` across the input list on multiple threads.
        // The function is passed by NAME (a string).
        results = proc.parallel_map([1, 2, 3, 4], "heavy")
        transmit(results)        // [1, 4, 9, 16]
    }
}

system Main {
    permit time.sleep            // sleeping is capability-gated (DoS guard)

    launch() {
        now = time.now()                          // current timestamp
        transmit(time.format(now, "%Y-%m-%d"))    // e.g. 2026-06-18

        a = time.now()
        time.sleep(1)                             // pause 1 second
        b = time.now()
        transmit("elapsed: " + str(time.diff(a, b)))

        // also: time.parse(iso8601), time.components(ts)
    }
}

system Main {
    permit fs.read("/tmp")       // grant read access under /tmp
    permit fs.write("/tmp")      // grant write access under /tmp

    launch() {
        fs.write("/tmp/log.txt", "mission start\n")
        if (fs.exists("/tmp/log.txt")) {
            transmit(fs.airlock("/tmp/log.txt"))   // read it back
        }
    }
}

system Main {
    permit net.transmit          // authorizes all net.* calls

    launch() {
        body = net.fetch("https://example.com/status")
        transmit(body)
    }
}

system Main {
    launch() {
        w = 240
        h = 180
        gfx.open(w, h, "Centauri Art")

        // vertical colour gradient background, drawn line by line
        for y in range(h) {
            shade = math.floor(y * 255 / h)
            gfx.line(0, y, w - 1, y, shade / 3, shade / 2, shade)
        }

        // a ring of circles placed with sin/cos
        cx = w / 2
        cy = h / 2
        count = 12
        for i in range(count) {
            angle = i * 6.2831853 / count
            x = cx + math.cos(angle) * 70
            y = cy + math.sin(angle) * 50
            red = math.floor(128 + 127 * math.sin(angle))
            grn = math.floor(128 + 127 * math.cos(angle))
            gfx.circle(x, y, 12, red, grn, 200)
        }

        gfx.circle(cx, cy, 18, 255, 255, 255)
        gfx.save("centauri_art.png")           // export — no display needed
        transmit("Wrote centauri_art.png")
    }
}

system Main {
    launch() {
        w = 480
        h = 360
        gfx.open(w, h, "Centauri — Bounce")

        x = 100  y = 80
        dx = 4   dy = 3
        r = 16

        orbit (gfx.is_open()) {
            // physics
            x = x + dx
            y = y + dy
            if (x < r or x > w - r) { dx = 0 - dx }   // bounce off walls
            if (y < r or y > h - r) { dy = 0 - dy }

            // arrow keys nudge the ball; ESC quits
            if (gfx.key("left"))  { x = x - 6 }
            if (gfx.key("right")) { x = x + 6 }
            if (gfx.key("escape")) { clip }

            // draw the frame
            gfx.clear(15, 15, 30)
            gfx.circle(x, y, r, 90, 200, 255)
            gfx.rect(0, h - 6, w, 6, 40, 40, 80)       // floor
            gfx.update()
        }
        transmit("done")
    }
}

system Main {
    launch() {
        // note name → frequency (Hz)
        notes = {"C": 261.63, "D": 293.66, "E": 329.63, "G": 392.0, "A": 440.0}
        tune  = ["E", "D", "C", "D", "E", "E", "E"]   // "Mary Had a Little Lamb"

        for name in tune {
            freq = notes[name]
            audio.tone("/tmp/note.wav", freq, 0.4)     // synthesize the note
            transmit("playing " + name + " (" + str(freq) + " Hz)")
            audio.play("/tmp/note.wav")                // blocks until it ends
        }
        transmit("samples per note: " + str(audio.duration("/tmp/note.wav")))
    }
}

system Main {
    permit os.write("/tmp")
    permit os.read("/tmp")
    permit os.exec("echo")

    launch() {
        // free reads — no permit needed for metadata / env / paths
        transmit("Platform: " + LaunchControl.Platform())   // macos/linux/windows
        transmit("User:     " + LaunchControl.Username())
        transmit("Home:     " + LaunchControl.HomeDir())
        transmit("CWD:      " + LaunchControl.GetCurrentDirectory())

        // build a working directory under the system temp dir
        dir = LaunchControl.JoinPath(LaunchControl.TempDir(), "centauri_demo")
        LaunchControl.MakeDir(dir)                  // needs os.write

        // write three files, then list them
        for i in range(3) {
            path = LaunchControl.JoinPath(dir, "file" + str(i) + ".txt")
            LaunchControl.WriteFile(path, "contents of file " + str(i))
        }
        files = LaunchControl.ListDir(dir)
        transmit("Files: " + str(files.sort()))

        // read one back; report its size
        first = LaunchControl.JoinPath(dir, "file0.txt")
        transmit("file0 size: " + str(LaunchControl.FileSize(first)) + " bytes")
        transmit("file0 text: " + LaunchControl.ReadFile(first))   // needs os.read

        // run an external command (needs os.exec)
        transmit("echo -> " + LaunchControl.Run("echo launched"))

        // clean up
        LaunchControl.DeleteDir(dir)
        transmit("cleaned up: " + str(LaunchControl.Exists(dir) == false))
    }
}

system Main {
    permit os.net("https://api.example.com")
    permit os.write("/tmp")

    launch() {
        // GET a document
        json = LaunchControl.Get("https://api.example.com/status")
        transmit(json)

        // download a file to disk (needs os.write for the destination)
        LaunchControl.Download("https://api.example.com/report.csv", "/tmp/report.csv")
        transmit("saved " + str(LaunchControl.FileSize("/tmp/report.csv")) + " bytes")

        // POST a body and read the reply
        reply = LaunchControl.Post("https://api.example.com/events", "{\"ok\":true}")
        transmit(reply)
    }
}

system Main {
    permit fs.read("/tmp")          // grant: read anything under /tmp

    launch() {
        transmit(fs.airlock("/tmp/data.txt"))   // allowed
        // fs.airlock("/etc/passwd")  // would be DENIED — outside the grant
    }
}

fn forever(n) { return forever(n + 1) }   // unbounded recursion

system Main {
    launch() {
        // the call-depth guard turns this into a catchable error,
        // not a host crash
        explore {
            forever(0)
        } divert(e) {
            transmit("safely caught: " + str(e))   // safely caught: Call stack overflow
        }
    }
}

fn is_even(n) { return n % 2 == 0 }

system Main {
    launch() {
        // Dictionaries
        scores = {"ada": 91, "alan": 85, "grace": 99}
        scores["linus"] = 88
        transmit("students: " + str(scores.keys()))
        transmit("grace -> " + str(scores["grace"]))

        // Functional pipeline over a range
        nums    = range(1, 11)
        evens   = nums.filter(fn(n) { return is_even(n) })
        squares = evens.map(fn(n) { return n * n })
        total   = squares.reduce(fn(a, b) { return a + b }, 0)
        transmit("even squares: " + str(squares))
        transmit("sum: " + str(total))

        // String methods
        csv   = "ada,alan,grace"
        names = csv.split(",").map(fn(n) { return n.upper() })
        transmit(names.join(" | "))

        // Math
        transmit("hypotenuse: " + str(math.sqrt(math.pow(3,2) + math.pow(4,2))))
        transmit("max score: " + str(max(scores["grace"], scores["ada"])))
    }
}

// Clamp a value into [lo, hi].
fn clamp(v, lo, hi) {
    if (v < lo) { return lo }
    if (v > hi) { return hi }
    return v
}

// CPU paddle AI: chase the ball when it is incoming, else drift to centre.
fn cpu_move(cur, ball_y, ball_vx, is_right, spd, H, pl) {
    active = (is_right and ball_vx > 0) or (not is_right and ball_vx < 0)
    target = H / 2 - pl / 2
    if (active) { target = ball_y - pl / 2 }
    d = target - cur
    if (math.abs(d) <= spd) { return clamp(target, 0, H - pl) }
    if (d > 0) { return clamp(cur + spd, 0, H - pl) }
    return clamp(cur - spd, 0, H - pl)
}

// A glowing paddle: dim halo, solid body, bright core stripe.
fn draw_paddle(x, y, w, h, r, g, b) {
    gfx.rect(x - 3, y - 3, w + 6, h + 6, r * 0.35, g * 0.35, b * 0.35)
    gfx.rect(x, y, w, h, r, g, b)
    gfx.rect(x + w / 3, y + 5, w / 3, h - 10,
             clamp(r + 50, 0, 255), clamp(g + 50, 0, 255), clamp(b + 50, 0, 255))
}

// Audio helpers — wrapped so a machine with no audio player never crashes.
fn safe_tone(path, freq, secs) {
    explore { audio.tone(path, freq, secs) } divert(e) { }
}
fn play_sound(path) {
    explore { audio.play_async(path) } divert(e) { }
}

system Main {
    launch() {
        W = 900  H = 560
        gfx.open(W, H, "Galactic Pong")

        // pre-generate sound effects once
        safe_tone("/tmp/gp_hit.wav", 700, 0.05)
        safe_tone("/tmp/gp_wall.wav", 480, 0.04)
        safe_tone("/tmp/gp_score.wav", 300, 0.16)

        // ball + paddle state
        bx = W / 2  by = H / 2
        bvx = 6     bvy = math.random() * 6 - 3
        ly = H / 2  ry = H / 2
        pl = 96     pspeed = 9
        br = 9

        orbit (gfx.is_open()) {
            if (gfx.key("escape")) { clip }

            // move the human paddle with the arrow keys
            if (gfx.key("up"))   { ly = clamp(ly - pspeed, 0, H - pl) }
            if (gfx.key("down")) { ly = clamp(ly + pspeed, 0, H - pl) }

            // advance the ball; bounce off the top/bottom walls
            bx = bx + bvx
            by = by + bvy
            if (by - br < 0) { by = br      bvy = -bvy  play_sound("/tmp/gp_wall.wav") }
            if (by + br > H) { by = H - br  bvy = -bvy  play_sound("/tmp/gp_wall.wav") }

            // render the frame
            gfx.clear(8, 8, 22)
            draw_paddle(24, ly, 14, pl, 255, 215, 0)        // gold = you
            gfx.circle(bx, by, br, 255, 228, 120)           // the ball
            gfx.update()
        }
        transmit("thanks for playing Galactic Pong!")
    }
}