about the project

A language for learning by thinking in systems.

Arandu is an experimental Brazilian systems language for native software: it aims for memory safety, explicit errors, clean syntax, and tools that help you understand what the compiler is doing.

the name

Arandu

In the project, the name expresses learning and intelligence: understanding the system so you can build better.

the direction

Principles that guide Arandu

These are not slogans detached from implementation. Each principle appears in the language, compiler, or tools being built today.

01

Control without obscurity

Arandu targets predictable native software while keeping syntax readable and close to the programmer’s reasoning.

02

Explicit memory

own, ref, mut, and shared make value decisions visible. The ownership model is evolving alongside the compiler.

03

Failures in the type flow

Option, Result, and ? keep absence and failure in the normal program flow instead of hiding them behind exceptions.

04

Tooling is part of the language

new, check, run, build, and doctor form the basic path; spans, diagnostics, and the LSP help fix problems at the source.

05

A verifiable foundation

CST, name resolution, types, AMIR, DataLayout, and incremental queries give the compiler structure as it grows.

06

Promise only what exists

The project separates working features, experimental pieces, and roadmap items. Technical honesty is a feature too.

no makeup

Where the project stands

Arandu is experimental. The clearest way to follow it is to separate the foundation that exists from the parts still being polished.

Today

lexer, parser, type checking, Option/Result, diagnostics, Cranelift JIT, native builds, CLI, Salsa, and LSP.

In progress

complete ownership syntax, C backend polish, custom Display, and a release-grade LLVM backend.

a language you can read

Clarity also lives in the code

module app

public func main(): void {
  let message: str = "hello, Arandu"
  io.println(message)
}

Values and functions use camelCase; types use PascalCase; modules stay lowercase. Simple conventions make programs predictable to read.