Skip to main content
Now in active development

The Aura Language

A modern, statically-typed programming language with a Rust-powered toolchain — compiled to native code, built for performance and clarity.

Get StartedStar on GitHub
NativeCode Output
ZeroRuntime Overhead
1 BinarySelf-Contained
main.aura
1// Aura — Fast, Safe, Expressive
2
3class Animal {
4  public name: string;
5  public sound: string;
6
7  public constructor(name: string, sound: string) {
8    this.name = name;
9    this.sound = sound;
10  }
11
12  public speak() {
13    print `${this.name} says ${this.sound}!`;
14  }
15}
16
17let dog = new Animal("Rex", "Woof");
18print dog.speak();  // Rex says Woof!
19
Why Aura

Everything you need to build fast

Aura is designed from first principles — a language and toolchain that prioritizes developer experience, performance, and correctness.

Blazing Performance

Aura compiles directly to native machine code via a custom backend — no VM overhead, no JIT warm-up, just raw AArch64 and x86_64 speed.

Rust-Powered Toolchain

The entire compiler infrastructure is written in Rust, giving you memory safety, fearless concurrency, and zero-cost abstractions throughout.

Smart Type Inference

A complete static type system with bidirectional inference — catch bugs at compile time without cluttering your code with redundant annotations.

Language Server (LSP)

Built-in LSP support gives you hover info, go-to-definition, completions, and real-time diagnostics in any editor right out of the box.

Generational GC

A statically-linked generational garbage collector keeps allocations fast and memory footprint small — all bundled in a single binary.

Complete Toolchain

One ecosystem: compiler, tree-walking interpreter, LSP server, standard library, and integration test suite — all in one repository.

Compiler Architecture

From source to binary in one pass

Aura's compiler pipeline is purpose-built for speed. Each stage is implemented from scratch in Rust, with no heavy external frameworks.

Source.aura files
LexerTokens
ParserAST
SemaTypes & Scopes
IRSSA Form
CodegenAArch64 / x64
BinaryNative exec
Clean Syntax

Familiar yet refined

Aura feels familiar to TypeScript and Rust developers — with cleaner syntax, no semicolons required, and native compilation.

fibonacci.aura
1function fib(n: number): number {
2  if (n <= 1) return n;
3  return fib(n - 1) + fib(n - 2);
4}
5
6print fib(10);  // 55
7
fibonacci.ts
1function fib(n: number): number {
2  if (n <= 1) return n;
3  return fib(n - 1) + fib(n - 2);
4}
5
6console.log(fib(10)); // 55
7

Start building with Aura

Read the docs, browse the source, or clone the repo and compile your first Aura program in minutes.

Read the DocsView Source
git clone https://github.com/auraspace/aura.git && cargo build