Source to a native executable, with nothing in between.

A program the compiler actually ran

This is examples/fibonacci.ael, compiled and run on this project's Linux x86-64 workstation. The transcript below is the real output, including the exit status.

// Compile-time types and checked arithmetic; no interpreter on the target.
fn fibonacci(n: i64) -> i64 {
    let mut a: i64 = 0;
    let mut b: i64 = 1;
    let mut i: i64 = 0;
    while i < n {
        let next: i64 = a + b;
        a = b;
        b = next;
        i = i + 1;
    }
    return a;
}

fn main() -> i64 {
    print(fibonacci(10));
    return fibonacci(20);
}

$ ael check fibonacci.ael
Checked fibonacci.ael

$ ael compile fibonacci.ael -o fibonacci.aelir --target linux-x86_64 --no-metrics
Compiled fibonacci.ael -> fibonacci.aelir (AEL IR 1.0, target linux-x86_64, 3446 bytes, cache miss)

$ ael build fibonacci.aelir -o fibonacci --target linux-x86_64 --profile linux-x86_64-scalar-v1 --no-metrics
Built fibonacci (native linux-x86_64, 4929 bytes; codegen cache miss, link cache miss)

$ ./fibonacci
55
$ echo $?
109

print takes i64 and bool and nothing else. AEL 0.1 cannot emit a string at all, so there is no “hello, world” to show you; the honest first program prints a number. The language page has six more programs, each with its real output and exit status.

The compiler is the whole toolchain

Checked by default, and honest about the gaps

Bounded by type. No heap, by decision.

AEL 0.1 defines no heap and no dynamic strings. That is a ruling, not a missing feature. Collections carry their capacity in the type, they never allocate, and an operation that will not fit hands back a typed carrier instead of trapping — leaving the value byte-identical.

let mut queue: Vec<i64, 3> = vec_empty();
vec_push(&mut queue, 10);
vec_push(&mut queue, 20);
vec_push(&mut queue, 30);

// The fourth push does not trap: it hands back Err and leaves the
// vector byte-identical.
let overflowed = vec_push(&mut queue, 40);
match overflowed {
    Result::Ok(nothing) => { return -1; },
    Result::Err(rejected) => { print(rejected == 40); },
}
print(vec_len(&queue) == 3);

The whole generic vocabulary is Option<T>, Result<T, E>, Vec<T, N> and Str<N>. User generics do not exist. Neither do floating-point numbers of any width, function values, threads, file I/O or a network stack. That is a small language, and the language page says exactly how small.

One platform executes

AEL 0.1 qualifies native execution for linux-x86_64 alone. The macos-aarch64 producer builds, links and format-verifies real Mach-O ARM64 images on this host, but no image it has written has been executed on a macOS machine since 8 September 2026, so 0.1 makes no execution claim for it. windows-x86_64 compiles to binary AEL IR and can be inspected; no Windows image has ever been produced. macOS and Windows are next-version scope.

The macOS image declares /usr/lib/dyld and /usr/lib/libSystem.B.dylib, so “needs only the kernel” is a property of the Linux image and is never generalised here to every target. The full platform position is on the status page.

About the name

Documentation and packages

Language documentation will live at docs.ael.openeng.ai and packages at pack.ael.openeng.ai. Neither is deployed today, so those links will not resolve yet; they are recorded here as the intended homes.

Package authorship is meant to be AEL-only: every AEL package, including HTTP and MCP servers, implemented in AEL, with the compiler and language primitives staying Rust. That is a requirement whose migration and enforcement are both pending — a Rust HTTP prototype still needs its AEL replacement, and no enforcement has been implemented. The ecosystem page states the requirement and its exact status.

What this site will not claim

This project holds every sentence to what the code enforces, so here is the short list of things that are not true of AEL today and will not be written anywhere on this site.

• Production ready, stable, or ready for real workloads.
• Any speed claim at all. No performance measurement of any kind exists in this project; there is no benchmark, no comparison, and the only optimization level is none.
• Cross-platform, or “runs on Linux, macOS and Windows”. One target executes.
• Install it today, download it, or any install command. Nothing has ever been distributed.
• Write agents in AEL. agent is a keyword that refuses to compile.
• A hello-world that prints text. It would not compile.
• Memory-safe with no crashes, or “every error is a checked failure”. Two failures escape the model.
• An AEL-only package ecosystem, delivered. It is a requirement with pending migration and enforcement.
• Fully tested or CI-verified. There is no CI at all, and no gate has ever run on a second machine.

The status page gives the evidence behind each of these.