Aura v0.1.1-alpha.8 • Compiled Service Language

Easy to write.
Boring to deploy.

Aura combines familiar classes, compile-time null safety, managed memory, and single-file native binaries in one Rust-powered toolchain.

$curl -fsSL https://aura.pilotworks.dev/install.sh | AURA_VERSION=0.1.1-alpha.8 bash
main.aura
package main

import std.io as Io

// Main entry point of the application
fun main() {
    // Print greeting message to standard output
    Io.println("Hello, Aura World!")

    // Instantiate and start backend service
    val server: Service = Service("aura-backend")
    server.start()
}

/// Service class with primary constructor parameter
class Service(val name: String) {
    fun start() {
        Io.println("Server " + this.name + " listening.")
    }
}
Compiler Outputaura build & run
[aura check] OK (12ms)
[aura build] Output: ./dist/main (4.2 MB)
$ ./dist/main
Hello, Aura World!
Server aura-backend listening.
Native executableZero framework overheadFast compilation
Language Foundations

Engineered for real-world backend services, without deploy friction.

Aura removes runtime setup headaches while providing language safety features expected in modern engineering.

Ergonomics

Familiar on Purpose

Classes, interfaces, methods, generics, and value types make service code easy to read and maintain without importing heavy frameworks.

Safety

Null Safety by Default

Variables are non-null by default. Optional types (T?) are explicit, and flow-sensitive compiler narrowing keeps safe paths direct.

Deployment

Self-Contained Native Binary

Garbage collector and runtime support link directly into the standalone binary. Zero runtime dependencies on the target server.

Concurrency

Explicit Concurrency

Spawn, join, channels, and task cancellation have explicit boundaries. The deterministic single-threaded executor prevents hidden races.

Developer Workflow

One unified CLI toolchain from local dev to production.

No extra build scripts, webpack configs, or third-party task runners needed.

terminal — aura check ./service
status: active
aura check ./service
[1/1] Checking package service...
  ✔  Syntax parsing complete (1.2ms)
  ✔  Symbol resolution complete (2.4ms)
  ✔  Type check & null-safety validation complete (3.8ms)
  
⚡  Checked 14 files in 7.4ms. 0 errors, 0 warnings.
Language Trade-offs

Where Aura fits in the ecosystem

Aura targets the sweet spot: high developer productivity with single-file native binaries and safety guaranteed at compile-time.

LanguageNull SafetyBinary & DeployMemory ManagementLearning Curve
AuraThis ProjectFlow-Sensitive Null SafetySingle Native ExecutableEmbedded Compact GCImmediate (Familiar OOP)
GoNil Pointer Exceptions possibleSingle Native BinaryConcurrent GCLow
Java / KotlinNull checks required at runtimeJAR / Requires JVMHeavy JVM GCMedium
RustStrict Lifetime & Borrow CheckerSingle Native BinaryManual / Lifetimes (No GC)High
Project Status

Useful today.Transparent about what comes next.

Aura is developed open source against 15 public RFC specifications, an extensive executable corpus, and repository examples.

100% Rust-powered compiler CLI
Native C codegen backend + runtime
Full test suite & corpus regression checks

Works Today

Ready
  • Check, build, run, test, format, and emit C from one Rust CLI.
  • Build multi-file packages with aura.toml and locked dependencies.
  • Get human-readable diagnostics or structured JSON for IDE tooling.
  • Compile real corpus programs and repository examples via C backend.

Intentionally Later

Roadmap
  • LLVM production backend target
  • General async lowering & multi-threaded scheduling
  • Hosted package registry & toolchain version manager
Explore Aura Ecosystem

Start with a small program, then inspect every design decision.

Read documentation guides to learn the language syntax, or inspect RFC specifications to understand architecture design choices.

AURA