v0.1 Preview

Low-level control. Guarantees your compiler can explain.

Arandu is an experimental systems language for people who want control over memory, execution, and binaries without giving up understandable diagnostics.

Create your first project See how the compiler works →

main.aru
import io

func main(): int {
  let message: str = "hello, arandu"
  io.println(message)
  return 0
}

The flow

From `.aru` source to native binary.

Each compiler stage makes the program’s progress visible.

main.aru

Your readable source file.

Lexer

Recognizes tokens and literals.

Parser + CST

Builds the concrete syntax tree.

Type checking

Checks names, types, and usage.

AMIR

Intermediate representation for analysis.

Cranelift

Generates host-native code.

Today

A small, executable foundation.

Arandu can already be explored as a language and as a tool.

$ _01

Projects and CLI

`new`, `doctor`, `check`, `run`, and `build` form the core workflow.

{ }02

Types and diagnostics

Name resolution, type checking, spans, and messages point to the problem.

▶03

Native execution

Cranelift provides JIT for `run` and native artifacts for `build`.

‹/›04

Editor tooling

The LSP provides diagnostics, hover, completion, references, rename, symbols, and format.

The model

Values have a clear history.

The language makes important decisions visible early.

let / mut: Immutable by default; mutation is declared.
own / ref: Ownership transfer or borrowed access.
Option<T>: Absence represented in the type.
Result<T, E>: Success and failure as explicit data.

Roadmap

The foundation is current. The ambition is larger.

Arandu is experimental, but the ambition is clear: memory, types, execution, and tooling should share the same mental model.

Create a project Understand the language