One artifact from source
aura build produces a single native executable. The GC and scheduler link into the binary — no runtime install on the host.
Open source · Rust toolchain
Write services thatleave as one binary.
Aura is a statically typed language with classes, null-safe types, and lightweight tasks. The runtime ships inside a single native executable.
MIT · 14 RFCs · compiler through C5n
Compile
hello.aura// C0 corpus
package main
fun main() {
println("Hello, Aura")
}
one binarynative
aura run hello.auraok
checkbuildrun
What you get
Small promises. Kept all the way to the binary.
Null-safe by default
T is non-null. T? is opt-in. Flow-sensitive narrowing keeps the safe path short and the escape hatch explicit.
Tasks, not thread soup
M:N lightweight tasks and channels for concurrent I/O. A class model without ownership ceremony.
Classes and value types
Classes and interfaces for the domain. Distinct structs when you want values, not references.
Toolchain is the language
check, build, run, test, and packages are first-class CLI verbs — not a pile of third-party scripts.
Designed in public RFCs
Vision, types, memory, runtime, and packages are written down before they ossify. Read the decisions, not just the code.
We kept choosing betweencomfort and a clean deploy.
Dynamic runtimes iterate fast, then leave you with two languages: the one you write and the one ops has to install. Systems languages are sharp and safe, but ownership ceremony is heavy for everyday service code.
Managed platforms are productive until the footprint and the ship story get in the way. Transpiled stacks bring libraries — and a second runtime gap.
Aura aims at the middle path: class-based productivity, concurrent tasks with GC, and a single native artifact you can copy onto a machine.
The language is Aura. The toolchain is Rust. The long path is LLVM; today a C backend already checks, builds, runs, and tests real packages from this repository.
The Aura method
From familiar source to one deployable file.
Write what you already know.
Classes, methods, interfaces, and a statement-oriented surface. Hello world needs no framework and no ceremony.
Let the compiler hold the line.
Nullability, exhaustiveness, and package boundaries surface early. Diagnostics are part of the product, not an afterthought.
Ship one file.
The default deploy story is a single executable you can copy onto a server, drop in a container, or hand out as a CLI.
Quiet proof
Spec first.Then the compiler.
The site you are on indexes the RFCs that lock the language, runtime, packages, and CLI — before features silently diverge.
- Nullability and Result live in the type system, not style guides.
- Single-binary deploy is a design principle, not a packaging tip.
- Corpus programs compile and run through the aura CLI today.