Python-inspired syntax with deterministic ownership, structured concurrency, and native executables.
curl -fsSL https://johnolafenwa.github.io/Aura/install.sh | sh
Aura is a compiled, statically typed language with familiar, indentation-based syntax. The compiler checks types, ownership, mutation, exhaustive matching, failure handling, and task boundaries. Programs build as native executables with deterministic cleanup and no garbage collector.
The current preview is designed for reliable applications, agent runtimes, machine learning (ML) infrastructure, evaluation workers, and control-plane services.
Aura is a technical preview. The language and its APIs may change before a stable release.
| Python | Rust | Aura | |
|---|---|---|---|
| Syntax | Indentation-based and concise | Explicit and low-level | Python-inspired and indentation-based |
| Types | Dynamic, with optional hints | Static | Static, with inference |
| Execution | Interpreter and virtual machine | Native executables | Native executables |
| Memory | Reference counting and garbage collection | Ownership | Ownership, no garbage collector |
| Failure | Exceptions | Result, Option, panics | Typed Result, Option, outcome enums |
| Concurrency | Threads and async functions | Threads and async ecosystem | Structured task groups across multiple cores |
| Current focus | General-purpose applications and scripting | Systems and application software | Reliable applications, agents, and ML infrastructure |
def scale(values: mut list[int64], factor: int64):
for value in mut values:
value *= factor
def total(values: list[int64]) -> int64:
mut sum = 0
for value in values:
sum += value
return sum
mut scores = [10, 20, 30]
scale(scores, 3)
print(f"scores: {scores}")
print(f"total: {total(scores)}")Each signature says what the function does to its arguments. scale asks for mut access and changes the list in place. total only reads it. The compiler enforces both contracts, and every operation is statically checked.
Serving models and running agents means working with sockets, subprocesses, queues, deadlines, and retries. Aura's rules make the ways these can fail visible in the code:
mut mutates, and own transfers. Cleanup follows the owning scope.Result, Option, or an outcome enum, and the code handles them where they happen.TaskGroup owns its child tasks. Leaving the scope joins them, cancels stragglers, and loses nothing.Aura aims to become a general-purpose systems language that can build every type of software. The intended scope spans applications, services, databases, language runtimes, embedded software, operating systems, and device drivers.
Aura 0.6 lays the foundation: static typing, deterministic ownership, native compilation, structured concurrency, typed failure, packages, and integrated tooling. Later releases will add freestanding compilation, low-level memory access, hardware interfaces, portable layout controls, cross-compilation, and specialized runtime profiles.
Aura publishes machine-readable documentation generated from the maintained Manual, Learn track, tutorials, installation guides, and project overview.
Read https://johnolafenwa.github.io/Aura/llms.txt first. Use https://johnolafenwa.github.io/Aura/llms-full.txt when you need complete language and tooling context. Treat the linked Manual as normative.
Install Aura, then run a file or build a native executable:
aura run program.au
aura build -o ./program program.auLearn Aura starts with runnable scripts and works up to tasks, typed failures, and I/O. The Manual is the normative reference. It covers the grammar, ownership rules, execution model, APIs, diagnostics, and limits.