AXON — AI-Native Programming Language

A compiler-first, AI-native programming language designed for AI models to write hyper-efficient native applications. Humans can't easily read or write it — that's the point.

S-Expressions C11 Compiler QBE Backend LLVM Backend Zero GC Cross-Platform

🚀 Get Started 🦊 View on GitLab

📖 What is AXON?

AXON (AI-Native eXecution Optimized Notation) strips away everything designed for human ergonomics — meaningful variable names, syntax sugar, implicit conversions, flexible formatting. What remains is a minimal, unambiguous, fully-explicit notation that a language model can emit deterministically, and a compiler can transform into optimal machine code with zero guesswork.

The source format is S-expressions (.axs files) — a fully parenthesized prefix notation that eliminates parsing ambiguity. Phase 2 will introduce a binary AST format (.axb files) that removes lexing and parsing entirely.

✨ Key Features

⚙️

Dual Backend

QBE IL for fast dev builds, LLVM IR for optimized release builds

🏷️

Enum Types

Nominal enums with explicit integer backing, eq/ne comparison, cast to int

🧬

Sum Types

Tagged unions with variant payloads, exhaustive matching, and payload extraction

🔀

Pattern Matching

Exhaustive match on enums, sum types, bools, integers with wildcard fallback

🔗

Function Pointers

First-class fnptr type with auto-coercion and indirect calls

📦

Structs & Arrays

Value-type structs, fixed-size arrays with pointer access

🎯

Type-Safe Casting

Explicit cast between int↔int, float↔float, int↔float, enum↔int

🌍

Cross-Platform

macOS (ARM64) and Linux (x86_64 / ARM64)

⚡

Zero Runtime Overhead

No GC, no dynamic dispatch, no bounds checking overhead

🔧 Compiler Pipeline

.axs text ──► Lexer ──► Parser ──► AST ──► TypeChecker ──► Typed AST ──► IR Lowering ──► AXON IR ──► (Optimizer) ──► QBE IL / LLVM IR ──► native binary

💡 Featured Example

Enum types with exhaustive pattern matching — a key feature of AXON's type system.

enum_match.axs

(module
  (extern print_i64 ((n i64)) void)
  (enum Color i32 ((Red 0) (Green 1) (Blue 2)))

  (fn color_value ((c Color)) i64
    (match c
      ((Color Red)   (i64 10))
      ((Color Green) (i64 20))
      ((Color Blue)  (i64 30))))

  (fn main () i32
    (block
      (call print_i64 (call color_value (Color Red)))
      (call print_i64 (call color_value (Color Green)))
      (call print_i64 (call color_value (Color Blue)))
      (i32 0))))

Output: 10 20 30

📊 Project Stats

🧪

76

Tests Passing

📝

~10,300

Lines of C

⚙️

2

Backends

🌍

3

Platforms

Pipeline: passing

76/76 tests · QBE + LLVM backends · macOS & Linux CI

📁 Project Structure

axon-lang/
├── Makefile                 # Build system
├── README.md                # Project overview
├── .gitlab-ci.yml           # CI/CD pipeline
├── docs/
│   ├── language-spec.md     # Complete language specification
│   ├── ai-guide.md          # AI agent programming guide
│   └── binary-format.md     # Binary AST format spec
├── src/
│   ├── axon.h               # Master header (types & interfaces)
│   ├── main.c               # Compiler driver & CLI
│   ├── arena.c              # Arena allocator
│   ├── lexer.c              # S-expression lexer
│   ├── parser.c             # S-expression parser → AST
│   ├── types.c              # Type system & checker
│   ├── ir.c                 # IR construction & lowering
│   ├── ast.c                # AST printer & utilities
│   ├── emit_qbe.c           # QBE IL code generation
│   └── emit_llvm.c          # LLVM IR code generation
├── runtime/
│   └── rt.c                 # Runtime library (print_i64, etc.)
└── tests/
    ├── programs/            # 65 program tests (.axs + .expected)
    └── errors/              # 11 error tests (.axs + .error)

🗺️ Roadmap

Phase 1 — Foundation Current

S-expression parser, type system, type checker, SSA IR, QBE & LLVM backends, enums, sum types, pattern matching, function pointers, structs, arrays, constants, pointers, strings, float types.

Phase 2 — Type System Expansion Active

Generics (monomorphized), distinct types, optional types, closures, modules & imports, C callback support, trait system.

Phase 3 — Advanced Features

Binary AST format (.axb), linear types, region-based memory, GUI framework, package manager, standard library.