Centauri — The Programming Language

Astronomy × Engineering

Where Centauri Burns

4.37 light-years away, the Alpha Centauri system is a trinary dance of stellar immense power. Two sun-like stars locked in binary orbit, with a red dwarf trailing on the perimeter. Our language carries that same architecture — complex concurrency powered by raw, close-to-metal heat.

0Light-YearsDistance from Sun

0Star SystemAlpha A, B & Proxima

0Luminosity (A)Brighter than our Sun

0Earth YearsBinary Orbital Period

0CE DiscoveryProxima Identified

The Language

A Starship
for Your Programs

Centauri compiles your source to bytecode, runs it on a Rust-native VM, and gets out of the way. The surface is sleek enough to learn in an afternoon — capsules for objects, orbit for loops, explore/divert for errors.

Under the hood the VM runs a mark-sweep GC, an M:N actor scheduler, and a RASP security engine that intercepts every I/O call. Phase 7 introduces the Chamber Import System and OS-level multiprocessing via the proc module.

Ph.0

Foundation

literals · arithmetic · orbit · if/else · clip

Ph.1

Functions & Lists

recursion · closures · first-class functions

Ph.2

Capsules

objects · methods · inheritance · super calls

Ph.3

Error Handling

explore/divert · jettison · pattern matching

Ph.4

RASP I/O

capability-gated fs · networking · GC

Ph.5

Actor Concurrency

spawn · send · receive · deadlock detection

Ph.6

Datetime

time.now · time.format · time.diff · time.sleep · time.parse

Ph.7

Imports & Proc

chamber · thread pools · atomics · mutexes

interstellar.cnt

// Centauri v1.0 — capability-secure language · Phase 7
chamber "telemetry"

system MissionControl {
  permit fs.read("/data/telemetry")
  permit net.transmit("https://api.nasa.gov")
  permit time.sleep("*")

  monitor(probe_id) {
    msg = receive
    transmit(msg)
  }

  start() {
    // Resolves from chamber
    t = telemetry.Sensor { temp: 5790, lum: 1.519 }
    transmit(t.report())

    // Phase 6: log current UTC time
    launch_ts = time.now()
    transmit(time.format(launch_ts, "[%Y-%m-%d %H:%M:%S UTC] ignition"))

    spawn monitor("starshot-alpha")

    // Phase 6: measure I/O latency
    t0 = time.now()
    explore {
      data = fs.airlock("/data/telemetry/stellar.log")
      transmit(data)
    } divert(err) {
      transmit(err)
    }
    elapsed = time.diff(t0, time.now()) * 1000
    transmit(elapsed)   // ms elapsed

    // Phase 6: countdown with sleep
    n = 3
    orbit (n > 0) {
      transmit(n)
      time.sleep(1)
      n = n - 1
    }
    transmit("lightspeed!")
  }
}

Architecture

Compiled to
Bytecode. Run in Rust.

The pipeline is Lexer → Parser → Analyzer → Compiler → VM. The compiler emits a compact bytecode chunk with a constant pool. The VM executes with a stack machine — fast, simple, auditable.

The RASP engine normalizes every tainted string through an iterative URL-decode loop before running ~80 regex rules. Inputs needing more than 8 decode passes to stabilize are blocked outright — over-encoding is itself a signal of attack.

pipeline.txt

// Compilation & execution pipeline

  source.cnt
       │
       ▼
  Lexer      // logos · zero-copy tokenization
  Token stream
       │
       ▼
  Parser     // recursive descent · AST
  Program AST
       │
       ▼
  Analyzer   // capability check · static security
  Verified AST
       │
       ▼
  Compiler   // bytecode emit · constant pool
  Chunk { code[], constants[] }
       │
       ▼
  Scheduler  // M:N actor runtime · PID registry
       │
       ▼
  VM         // stack machine · GC · RASP engine
       │
       ▼
  Output + Security

Capabilities

Built for the Frontier

🛡

Capability-Based Security

Every I/O call requires a static permit before a single instruction runs. The analyzer rejects unpermitted access at compile time — not at runtime, not with exceptions.

compile-time

🔒

RASP Self-Protection

80+ rules across SQL injection, XSS, command injection, SSRF, XXE, and WAF-bypass patterns. Tainted strings are normalized before scanning.

runtime

⚛

Actor Concurrency

spawn, send, receive. Each actor owns an isolated VM heap — no shared memory, no data races. M:N scheduler handles the load.

phase 5

🚀

Capsule Inheritance

Object-oriented via capsules — single inheritance, super dispatch, first-class closures with mutable upvalue capture that persists across calls.

phase 2

🔥

Mark-Sweep GC

Heap objects (capsules, lists, closures) managed automatically. The GC threshold doubles after each collection cycle, amortising overhead.

automatic

🔭

Taint Tracking

Every string from file or network I/O is marked tainted. Taint propagates through operations. At every I/O boundary, tainted strings are re-scanned.

security

🎯

Pattern Matching

match supports numeric literals, strings, Vacuum, capsule type-check, binding variables, and wildcards. Arms short-circuit.

phase 3

☄️

explore / divert

Centauri's error model: explore the risky path, divert when something is jettisoned. Full stack and locals unwinding.

phase 3

⚡

Native Compilation

centauri compile serialises bytecode + function tables, generates a standalone Rust project, and emits a fully native binary.

aot

🕐

Datetime Module

Phase 6 adds time.now(), time.format(), time.diff(), and more. Timestamps are Unix epoch Floats — pure std.

phase 6

📅

Format Tokens

time.format(ts, fmt) supports 21 tokens for ISO, log-style, and millisecond-precision human-readable output.

phase 6

⏱

Timers & Sleep

Measure elapsed time with time.diff(a, b). time.sleep(secs) blocks an actor for a precise duration.

phase 6

📦

Chamber Imports

File-level module imports resolved safely at compile-time with idempotent diamond dependency handling.

phase 7

🧵

OS Threads & Pools

Scale beyond cooperative actors with true OS threads, futures, and managed thread pools via proc.*.

phase 7

🚥

Hardware Synchronization

Lock-free proc.atomic_* calls, mutexes, and thread barriers safely shared via handle IDs.

phase 7

RASP Engine

Security in the Corona

Three independent layers. None can be bypassed by the program being run.

L1Capability SystemCompile time

L2Taint PropagationVM runtime

L3RASP Rule EngineI/O boundary

NNormalization PipelinePre-scan

① Iterative URL-decode · max 8 passes · excess = BLOCK

② Unicode fullwidth fold (ｓｅｌｅｃｔ → select)

③ Null-byte strip

④ Whitespace collapse

⑤ HTML entity decode (< → < etc.)

⑥ Lowercase

Threat Coverage

Shielded from
Every Angle

The rule engine covers the OWASP Top 10 and beyond. Path rules fire before every filesystem call. Payload rules run on every string crossing an I/O boundary. Header rules protect every network send.

SQL InjectionXSSCommand Injection Path TraversalSSRFXXE LDAP InjectionSSTIHeader Injection Log InjectionShell UploadCRLF Injection HTTP SmugglingOpen RedirectCredential Leak Double EncodingUnicode BypassNull Byte

Language Design

Keywords from the Stars

Every keyword in Centauri is themed to its legacy roots while the execution engine burns hotter.

orbitLoop / WhileRepeat while a condition holds — like Alpha Centauri A and B locked in binary revolution.

capsuleClass / ObjectA sealed, pressure-rated unit of data and behaviour. Fields, methods, inheritance.

transmitPrint / OutputSend data outward — like a star radiating telemetry across the void of space.

jettisonThrow / ErrorEject an error payload. Caught by the nearest explore/divert handler or terminates the actor.

exploreTry BlockVenture into uncertain territory. If something goes wrong, the divert block handles the fallout.

divertCatch BlockChange course when the explore block jettisons. The error value is bound to your variable.

dockImport / UseAlign with a module — establish a connection and bring its capabilities aboard.

airlockfs.airlock (Read)Pass data through a security boundary. Every byte is scanned by the RASP engine.

permitCapability GrantGrant an explicit I/O capability. Without it the analyzer refuses to compile the call.

spawnStart ActorLaunch a new actor into the scheduler. Isolated heap, own mailbox, parallel execution.

receiveAwait MessageBlock the current actor until a message arrives in its mailbox. Scheduler yields the thread.

clipBreak LoopExit the innermost orbit immediately — compiled to a patched jump to the loop's end IP.

chamberImport ModuleResolves file dependencies at compile time and securely merges opcodes into the host chunk.

proc.threadSpawn OS ThreadDeep-copies the VM class registry and heap, spinning up a true parallel OS thread.

pool_submitAsync FutureDispatch heavy work to a background thread pool worker and await its future result.

atomic_addLock-Free SyncHardware-level atomic operations mapped via handles, bypassing race conditions.

Phase 5

Stellar Nodes

Each actor is an isolated VM burning on its own thread. Messages are primitive values — no shared memory, no data races. The M:N scheduler distributes the immense workload across all CPU cores.

Phase 6

Relativistic Time

Six functions for everything temporal — current time, formatting, elapsed measurement, sleeping, and parsing. All UTC. All pure std. Timestamps are just Floats.

time.now() simulation

time_demo.cnt

system TimeDemo {
  permit time.sleep("*")

  start() {
    // Current time
    now = time.now()
    transmit(time.format(now,
      "%Y-%m-%dT%H:%M:%S"))

    // Stopwatch
    t0 = time.now()
    i = 0
    orbit (i < 1000000) { i = i + 1 }
    ms = time.diff(t0, time.now()) * 1000
    transmit(ms)   // elapsed ms

    // Parse
    flyby = time.parse("2015-07-14")
    days = time.diff(flyby, now) / 86400
    transmit(days)

    // Countdown
    n = 3
    orbit (n > 0) {
      transmit(n)
      time.sleep(1)
      n = n - 1
    }
  }
}

Phase 7 — New

Chamber & Proc

A production-grade leap. Modularize with compile-time chamber imports, and break the cooperative actor bounds with true OS-level multithreading and managed thread pools.

Module System

Compile-time
Chamber Imports

The chamber keyword resolves .cnt dependencies safely before runtime. It automatically manages diamond dependencies and namespaces imported functions by their file stem to prevent collisions.

app.cnt

chamber "math_ops"
chamber "utils/crypto"

system Main {
  launch() {
    hash = crypto.sha256("payload")
    val  = math_ops.square(12)
    transmit(val)
  }
}

Multiprocessing

True OS Threads
& Pools

While Phase 5 actors run cooperatively, the proc module exposes an 18-syscall suite for OS-level threads. Distribute CPU-heavy workloads across pools, parallel maps, and synchronize safely with lock-free atomics and mutexes.

threads.cnt

system Main {
  launch() {
    // Initialize pool and hardware atomic
    pool = proc.thread_pool(4)
    counter = proc.atomic_new(0.0)

    // Submit work to thread pool
    f1 = proc.pool_submit(pool, "process", 1, counter)
    f2 = proc.pool_submit(pool, "process", 1, counter)

    // Await futures and shutdown
    proc.pool_await(f1)
    proc.pool_await(f2)
    proc.pool_shutdown(pool)
    
    transmit(proc.atomic_get(counter))
  }
}

Nearest Star.
Infinite
Reach.

Where Centauri Burns

A Starship
for Your Programs

Compiled to
Bytecode. Run in Rust.

Built for the Frontier

Security in the Corona

Shielded from
Every Angle

Keywords from the Stars

Stellar Nodes

Relativistic Time

Chamber & Proc

Compile-time
Chamber Imports

True OS Threads
& Pools

The Nearest Star.
The Greatest Speeds.

Nearest Star.InfiniteReach.

Where Centauri Burns

A Starshipfor Your Programs

Compiled toBytecode. Run in Rust.

Built for the Frontier

Security in the Corona

Shielded fromEvery Angle

Keywords from the Stars

Stellar Nodes

Relativistic Time

Chamber & Proc

Compile-timeChamber Imports

True OS Threads& Pools

The Nearest Star.The Greatest Speeds.

Nearest Star.
Infinite
Reach.

A Starship
for Your Programs

Compiled to
Bytecode. Run in Rust.

Shielded from
Every Angle

Compile-time
Chamber Imports

True OS Threads
& Pools

The Nearest Star.
The Greatest Speeds.