Axe Programming Language

Why Axe?

Explicit by Design

Every allocation, mutation, and side effect is visible in code. No hidden costs. Write code that does exactly what it says.

Built for Concurrency

Parallel constructs are first-class citizens. Write concurrent code that's both safe and performant with intuitive parallel for loops and clear semantics.

Memory Safe

Strong type system and compile-time checks help prevent common memory errors. Get the performance of systems programming without the crashes.

Cross-Platform

Write platform-specific code elegantly with built-in platform blocks.

Zero-Cost Abstractions

High-level features compile down to efficient machine code. No runtime overhead or garbage collection pauses.

Testing Built-In

Write tests directly alongside code with integrated test blocks. Keeps code reliable from day one.

Readable Syntax

Axe's syntax is designed to be clear and expressive. Explicit mutability markers, straightforward control flow, and powerful platform-specific code blocks make intentions completely clear.

Arena-Based Memory Management

use std.arena;
use std.io;

model Node {
    value: i32;
    next: ref Node;
}

/// Allocate a new Node from the arena
def new_node(arena: ref Arena, value: i32): ref Node {
    mut n: ref Node = Arena.alloc(arena, sizeof(Node));
    n.value = value;
    n.next = nil;
    return n;
}

/// Push a new value to the front of the list
def list_push_front(head: ref Node, arena: ref Arena, value: i32): ref Node {
    mut new_head = new_node(arena, value);
    new_head.next = head;
    return new_head;
}

Platform-Specific Code Blocks

def cross_platform_func() {
    platform windows {
        parallel for mut i = 0; i < 10; i++ {
            println i;
        }
    }
    platform posix {
        parallel for mut i = 0; i < 10; i++ {
            println i;
        }
    }
}

platform windows {
    def some_function() {
        println "hi from windows!";
    }
}

platform posix {
    def some_function() {
        println "hi from posix!";
    }
}

Parallel Processing Made Simple

/// Process data in parallel across multiple threads
def parallel_processing(data: i32[], size: i32) {
    parallel for mut i = 0; i < size; i++ {
        // Each iteration runs in parallel
        data[i] = data[i] * 2;
    }
}

/// Compute intensive operations benefit from parallelism
def matrix_multiply(a: f64[][], b: f64[][], n: i32) {
    parallel for mut i = 0; i < n; i++ {
        for mut j = 0; j < n; j++ {
            mut sum = 0.0;
            for mut k = 0; k < n; k++ {
                sum = sum + a[i][k] * b[k][j];
            }
        }
    }
}

Conway's Game of Life

/// Counts the live neighbors
def count_neighbors(grid: i32[height][width], x: i32, y: i32, 
                    width: i32, height: i32): i32 {
    mut count: i32 = 0;
    for mut dy = -1; dy <= 1; dy++ {
        for mut dx = -1; dx <= 1; dx++ {
            if dx == 0 and dy == 0 { continue; }
            val nx = x + dx;
            val ny = y + dy;
            if nx >= 0 and nx < width and ny >= 0 and ny < height {
                count = count + grid[ny][nx];
            }
        }
    }
    return count;
}

/// Compute next generation
def next_generation(grid: i32[height][width], 
                     new_grid: i32[height][width],
                     width: i32, height: i32) {
    for mut y = 0; y < height; y++ {
        for mut x = 0; x < width; x++ {
            val neighbors = count_neighbors(grid, x, y, width, height);
            if grid[y][x] == 1 {
                new_grid[y][x] = (neighbors == 2 or neighbors == 3) ? 1 : 0;
            } else {
                new_grid[y][x] = neighbors == 3 ? 1 : 0;
            }
        }
    }
}

Type-Safe Enumerations

enum State {
    RUNNING,
    CHANGING,
    STOPPED
}

enum Result {
    SUCCESS,
    ERR,
    PENDING
}

main {
    mut fixed_state: State = State.CHANGING;
    println State.RUNNING;
    println fixed_state;
    
    if fixed_state == State.CHANGING {
        fixed_state = State.RUNNING;
        println "State changed to RUNNING";
    }
    
    val result: Result = Result.SUCCESS;
    println result;
}

Cross-Platform Support

Write once, deploy anywhere. Axe's platform blocks allow for targeting multiple operating systems while maintaining clean, readable code.

🪟

Windows

🐧

Linux

🍎