Aether Programming Language

A compiled actor-based programming language with type inference, designed for concurrent systems. Aether compiles to C for native performance and seamless C interoperability.

Overview

Aether is a compiled language that brings actor-based concurrency to systems programming. The compiler generates readable C code, providing portability and interoperability with existing C libraries.

Core Features:

• Actor-based concurrency with automatic multi-core scheduling
• Type inference with optional annotations
• Compiles to readable C for portability and C library interop
• Lock-free message passing with adaptive optimizations
• Go-style result types: a, err = func() with _ discard
• Package management: ae add host/user/repo[@version] (GitHub, GitLab, Bitbucket, any git host)

Runtime Features

The Aether runtime implements a native actor system with optimized message passing:

Concurrency Model

• Multi-core partitioned scheduler with locality-aware actor placement
• Locality-aware spawning — actors placed on the caller's core for efficient parent-child messaging
• Message-driven migration — communicating actors automatically converge onto the same core
• Work-stealing fallback for idle core balancing
• Lock-free SPSC queues for same-core messaging
• Cross-core messaging with lock-free mailboxes

Memory Management

• Manual by default — use defer for cleanup. All allocations cleaned up explicitly.
• Arena allocators for actor lifetimes
• Memory pools with thread-local allocation
• Actor pooling reducing allocation overhead
• Zero-copy message delivery in single-actor main-thread mode (caller stack passed directly)

Message Optimization

• Sender-side batching for reduced overhead
• Message coalescing for higher throughput
• Adaptive batching dynamically adjusts batch sizes
• Direct send for same-core actors bypasses queues

Platform Portability

• Compile-time platform detection via AETHER_HAS_* flags (threads, atomics, filesystem, networking, NUMA, SIMD, affinity)
• Cooperative scheduler for single-threaded platforms (WebAssembly, embedded, bare-metal)
• Graceful degradation — stdlib stubs return errors when features are unavailable
• ae build --target wasm compiles to WebAssembly via Emscripten
• PLATFORM=wasm|embedded Makefile targets for cross-compilation
• Docker CI images for Emscripten (WASM) and ARM (embedded) verification

Advanced Features

• Actor timeouts — receive { ... } after N -> { ... } fires handler if no message arrives within N ms
• Cooperative preemption (opt-in) — AETHER_PREEMPT=1 breaks long handlers, --preempt yields at loop back-edges
• SIMD batch processing with AVX2 support
• NUMA-aware allocation for multi-socket systems
• CPU feature detection for runtime optimization selection
• Performance profiling with per-core cycle counting
• Message tracing for debugging

Benchmarks

Aether includes a comprehensive cross-language benchmark suite comparing actor implementations across 11 languages. Run make benchmark to evaluate performance on your system.

See benchmarks/cross-language/ for methodology and implementation details.

Quick Start

Install

Linux / macOS — one-line install:

git clone https://github.com/nicolasmd87/aether.git
cd aether
./install.sh

Installs to ~/.aether and adds ae to your PATH. Restart your terminal or run source ~/.bashrc, ~/.zshrc, or ~/.bash_profile.

Windows — download and run:

1. Download aether-*-windows-x86_64.zip from Releases
2. Extract to any folder (e.g. C:\aether)
3. Add C:\aether\bin to your PATH
4. Restart your terminal (so PATH takes effect)
5. Run ae init hello && cd hello && ae run

GCC is downloaded automatically the first time you run a program (~80 MB, one-time) — no MSYS2 or manual toolchain setup required.

All platforms — manage versions with ae version:

ae version list              # see all available releases
ae version install v0.25.0   # download and install a specific version
ae version use v0.25.0       # switch to that version

Your First Program

# Create a new project
ae init hello
cd hello
ae run

Or run a single file directly:

ae run examples/basics/hello.ae

Editor Setup (Optional)

Install syntax highlighting for a better coding experience:

VS Code / Cursor:

cd editor/vscode
./install.sh

This provides:

• Syntax highlighting with TextMate grammar
• Custom "Aether Erlang" dark theme
• .ae file icons

Development Build (without installing)

If you prefer to build without installing:

make ae
./build/ae version
./build/ae run examples/basics/hello.ae

The ae Command

ae is the single entry point for everything — like go or cargo:

ae init <name>           # Create a new project
ae run [file.ae]         # Compile and run (file or project)
ae build [file.ae]       # Compile to executable
ae check [file.ae]       # Type-check without compiling (~30x faster)
ae test [file|dir]       # Discover and run tests
ae examples [dir]        # Build all example programs
ae add <host/user/repo>  # Add a dependency (any git host)
ae repl                  # Start interactive REPL
ae cache                 # Show build cache info
ae cache clear           # Clear the build cache
ae version               # Show current version
ae version list          # List all available releases
ae version install <v>   # Install a specific version
ae version use <v>       # Switch to an installed version
ae help                  # Show all commands

In a project directory (with aether.toml), ae run and ae build compile src/main.ae as the program entry point. You can also pass . as the directory: ae run . or ae build ..

Using Make (alternative):

make compiler                    # Build compiler only
make ae                          # Build ae CLI tool
make test                        # Run runtime C test suite (166 tests)
make test-ae                     # Run .ae source tests (95 tests)
make test-all                    # Run all tests
make examples                    # Build all examples
make -j8                         # Parallel build
make help                        # Show all targets

Windows: Use the release binary — no MSYS2 needed. To build from source, use MSYS2 MinGW 64-bit shell; make ci runs the full suite (compiler, ae, stdlib, REPL, C tests, .ae tests, examples) with no skips.

Project Structure

aether/
├── compiler/           # Aether compiler (lexer, parser, codegen)
│   ├── parser/        # Lexer, parser, tokens
│   ├── analysis/      # Type checker, type inference
│   ├── codegen/       # C code generation, optimizer
│   └── aetherc.c      # Compiler entry point
├── runtime/           # Runtime system
│   ├── actors/        # Actor implementation and lock-free mailboxes
│   ├── config/        # Platform detection, optimization tiers, runtime config
│   ├── memory/        # Arena allocators, memory pools, batch allocation
│   ├── scheduler/     # Multi-core scheduler + cooperative single-threaded backend
│   └── utils/         # CPU detection, SIMD, tracing, thread portability
├── std/               # Standard library
│   ├── string/       # String operations
│   ├── file/         # File operations (open, read, write, delete)
│   ├── dir/          # Directory operations (create, delete, list)
│   ├── path/         # Path utilities (join, basename, dirname)
│   ├── fs/           # Combined file/dir/path module
│   ├── collections/  # List, HashMap, Vector, Set, PQueue
│   ├── list/         # Dynamic array (ArrayList)
│   ├── map/          # Hash map
│   ├── json/         # JSON parser and builder
│   ├── http/         # HTTP client and server
│   ├── tcp/          # TCP client and server
│   ├── net/          # Combined TCP/HTTP networking module
│   ├── math/         # Math functions and random numbers
│   ├── io/           # Console I/O, environment variables
│   ├── os/           # Shell execution, command capture, env vars
│   └── log/          # Structured logging
├── tools/            # Developer tools
│   ├── ae.c          # Unified CLI tool (ae command)
│   └── apkg/         # Project tooling, TOML parser
├── tests/            # Test suite (runtime, syntax, integration)
├── examples/         # Example programs (.ae files)
│   ├── basics/       # Hello world, variables, arrays, etc.
│   ├── actors/       # Actor patterns (ping-pong, pipeline, etc.)
│   └── applications/ # Complete applications
├── docs/            # Documentation
└── docker/          # Docker (CI, dev, WASM, embedded)

Language Example

// Counter actor with message handling
message Increment {}
message Decrement {}
message Reset {}

actor Counter {
    state count = 0

    receive {
        Increment() -> {
            count = count + 1
        }
        Decrement() -> {
            count = count - 1
        }
        Reset() -> {
            count = 0
        }
    }
}

main() {
    // Spawn counter actor
    counter = spawn(Counter())

    // Send messages
    counter ! Increment {}
    counter ! Increment {}
    counter ! Decrement {}