Aura

Aura is a gradually-typed programming language that transpiles to Python. It combines a clean, unambiguous syntax with the entire Python ecosystem: first-class PyPI interop, a standard library, native threads and coroutines, and post-quantum cryptography.

Status: alpha (0.1.0a7). The syntax is standardized and frozen for the alpha series; see the grammar and the changelog.

Installation

pip install aura-language            # from PyPI
# or from a checkout:
pip install .
aura run examples/hello.aura

Optional post-quantum backend (recommended for real secrets):

pip install "aura-language[pqc]"     # adds cryptography>=44 (ML-KEM/ML-DSA)

Requires Python 3.10+. The runtime has no mandatory third-party dependencies (on 3.10, tomli is installed automatically for reading aura.toml).

Quick Start

aura init myapp
aura run myapp/src/main.aura

From a source checkout without installing:

git clone https://github.com/JoaoValentimTheo/aura-lang.git
cd aura-lang
python3 main.py run examples/hello.aura

The Language

Aura has exactly one spelling per construct — no synonyms. The full grammar lives in docs/GRAMMAR.md. Highlights:

// Functions, generics and traits.
def max[T](a: T, b: T) -> T {
  return a > b ? a : b
}

trait Shape {
  public def area() -> float
}

class Circle implements Shape {
  private let r: float = 1.0
  public def new(r: float) { self.r = r }
  public def area() -> float { return 3.14159 * self.r * self.r }
}

def parse(text) -> int | none {
  guard text.length() > 0 else { return none }
  return try { int(text) } catch e { none }
}

// The entry point: `aura run` invokes `main` for you.
def main() {
  // Immutable by default; opt into mutation.
  let name = "Aura"
  let mut count = 0
  count += 1

  // Pattern matching, pipes, guard clauses, error handling.
  let label = match count {
    case 0 -> "zero"
    case n if n > 0 -> "positive"
    case _ -> "other"
  }

  let sum = [1, 2, 3, 4] |> filter((x) => x % 2 == 0) |> reduce((a, x) => a + x, 0)
}

Canonical spellings include def (not fn), new (not init), none (not null), not/and/or (not !/&&/||), and [T] generics (not <T>). Removed spellings raise a clear SyntaxError.

Concurrency

Aura supports native OS threads and async def/await.

Threads (globals are shared; guard them with a lock):

import stdlib.threading as threading

let mut total = 0
let lock = threading.lock()

def worker(n) {
  let mut i = 0
  while i < n {
    lock.acquire()
    total += 1
    lock.release()
    i += 1
  }
}

def main() {
  let t = threading.spawn((x) => worker(x), 100)
  t.join()
  print(total)
}

Coroutines:

import stdlib.asyncio as aio

async def work(n) {
  await aio.sleep(0.01)
  return n * 2
}

async def main() {
  let results = await aio.gather(work(1), work(2), work(3))
  print(results)
}

See aura/stdlib/README.md for the full API.

Cryptography

stdlib.crypto provides real SHA-2/SHA-3/SHAKE hashing, HMAC, HKDF and secure randomness, plus post-quantum ML-KEM (FIPS 203) and ML-DSA (FIPS 204) behind a pluggable backend. Install the pqc extra for a vetted implementation; otherwise a clearly-labelled reference backend is used and require_production_backend() fails loudly.

import stdlib.crypto as crypto

def main() {
  print(crypto.sha3_256("hello"))

  let kp = crypto.kem_keypair()
  let enc = crypto.kem_encapsulate(kp.public_key)
  let shared = crypto.kem_decapsulate(kp.secret_key, enc.ciphertext)

  let signer = crypto.dsa_keypair()
  let sig = crypto.dsa_sign(signer.secret_key, "payload")
  print(crypto.dsa_verify(signer.public_key, "payload", sig))
}

Python Interop

Aura transpiles to Python, so community PyPI packages are first-class. Install one with aura add, declare it in aura.toml, then import it directly, or use the explicit bridge for dynamic access:

import python

def main() {
  let requests = python.import_module("requests")
  let text = requests.get("https://example.com").text

  let re = python.load("re")
  print(re.findall("[0-9]+", "a1b22c333"))

  print(python.eval("sum(range(10))"))
}

The bridge exposes import_module, load, eval, exec_code, call, getattr/setattr/hasattr, is_available, to_aura/to_python, and more. See aura/stdlib/python.py.

Aura Patterns (AUP)

AUP is a catalog of idiomatic solutions — option, builder, strategy, pipelines, error handling, memoization, observer, resource management, worker pools and hybrid crypto. Every pattern is a runnable program under examples/aup/:

CLI

Installed as aura <command>; the same commands work via python3 main.py <cmd>.

REPL

aura repl

aura> let mut total = 0
aura> for i in 1..5 { total += i }
aura> total
10
aura> :type total
int  (value: 10)
aura> import python
aura> python.eval("2 ** 8")
256
aura> :q

The REPL enforces the same rules as aura check, including mutability across chunks, and supports top-level await.

A bare expression prints its value and stores it in _. Multi-line input continues automatically while brackets are open or a line ends with a continuation token.

Documentation

• Documentation index
• Grammar (canonical source of truth)
• Diagnostics reference (E##/W##)
• Language Reference · Referência da Linguagem
• Aura Patterns (AUP)
• Standard Library
• Type System · Sistema de Tipos
• Architecture
• Contributing · Security · Changelog

Development

python3 -m venv .venv && source .venv/bin/activate
pip install -e ".[dev]"            # pytest, coverage, hypothesis, ruff, mypy

python -m pytest tests/ -q         # full suite
python -m pytest tests/ --cov=aura # with coverage (floor: 65%)
ruff check aura/                   # lint
mypy aura/                         # types

The suite covers every syntax construct, the full object system, concurrency, cryptography and hardening regressions, and runs the generated .aura corpora. It also includes property-based tests (Hypothesis) for the lexer, parser and transpiler, a differential suite that compares Aura against equivalent Python, and tests that enforce the diagnostics catalogue and the Aura Pattern standard. See CONTRIBUTING.md for the architecture and how to add a language feature.

License

MIT — see LICENSE.