Readable code. Tiny native binaries.

A readable systems language that compiles straight to native code. No VM, no garbage collector, no libc.

main.azcompiles to 180 bytes

enum FD
    Stdin
    Stdout
    Stderr

@link("./sdk/src/write.s")
op write(FD fd, const str val, const int size): void

@link("./sdk/src/exit.s")
op exit(const int val): void

write(Stdout, "Hello World from AzLang!\n", 25)
exit(0)

180BStandalone hello world ELF

0Runtime dependencies

_startDirect entry, no crt1.o

Why AzLang

Reliability through absence.

The most resilient machine has no unnecessary moving parts. AzLang removes the layers between your code and the silicon.

Zero-VM execution

The kernel hands control straight to your code. Nothing runs before it, nothing runs beside it.

Virtual machine
Garbage collector
libc and crt runtime
Exception unwind tables
Your program, then the kernel

Readable by default

Blocks by indentation. No braces, no semicolons.

Explicit mutability

const by default, var when state must change.

Direct ABI interop

Include any assembly source with @link and call it as a native op.

Deterministic

No GC pauses or hidden threads. Inspect it all with gdb and strace.

Bytes, not megabytes.

AzLang 180 B

Compiles in milliseconds
Assembled and linked in one fasm pass
Bare metal, embedded, microservices

Heavy toolchains 5 to 50 MB

Seconds to minutes
libc, libm, libpthread
Servers and desktops

How the Zero-VM model works

Small surface. Sharp edges removed.

Functions are `op`s

Parameters declare their own mutability. const passes by value, var passes a mutable reference.

op add(const int a, const int b): int
    return a + b

op multiply(var int x, const int factor): int
    return x * factor

op log_message(const str msg, const int len): void
    write(Stdout, msg, len)

Blocks by indentation

if, elif, else, while, for ... in for iteration, and a bare loop that runs forever.

var int i = 0

while i < 10
    i = i + 1

const list<int> items = [10, 20, 30]

for items in item
    // use item

loop
    if should_stop
        break

Types that map to registers

Every primitive lowers to a concrete machine word. Template strings are built in.

const int count = 42
const bigint offset = 1000000000
const float ratio = 0.75
const char initial = 'A'

const str name = "AzLang"
const str msg = `Welcome to ${name}`

Enums: Zero-cost byte inlining

Variants are resolved at compile-time as immediate constants. No memory loads, no runtime lookup tables.

enum FD
    Stdin
    Stdout
    Stderr

write(Stdout, "Hello\n", 6)

// emitted assembly: the variant is an immediate, no lookup table
mov rax, 1
push rax
lea rax, [main_str0]
push rax
mov rax, 6
push rax
pop rdx
pop rsi
pop rdi
call write

The compiler

One shot, source to silicon.

A single self-contained compiler takes your source to a native binary in one fasm pass. No daemons, no object files, no separate linker.

Tokenize.az
ParseAST
Validatetypes
Emit.asm
Assemblefasm
BinaryELF

Compiler internals

Reliability comes from engineering unnecessary valves and moving parts out of the machine entirely.
The AzLang Doctrine

One command to install.

AzLang's only dependency is fasm — one small assembler binary. Install it and start writing.

Install AzLang

sudo pacman -S azcli