A - AI-Native Programming Language

Purpose-Driven Features

Every feature is designed to maximize AI leverage while maintaining human readability

Immutability by Default

Uses `let` for immutable variables by default, with `var` only when mutation is necessary. Reduces side-effects and simplifies AI reasoning about code behavior.

Expression-Oriented

Functions and control structures are expressions wherever possible, encouraging concise, single-expression code that's easier for AI to understand and manipulate.

Explicit Types

Types and ownership are explicit when necessary, reducing AI ambiguity and minimizing type inference errors that can confuse LLMs during code generation.

Intent Annotations

Optional `@intent:` comments allow AI-guided code generation without affecting compilation, providing clear communication of purpose to AI tooling.

Multi-Target Backend

Native LLVM backend for maximum performance, with optional WebAssembly target and WASI for secure sandboxed execution environments.

Homoiconic AST

Provides AI with a canonical structure for manipulation and code transformation, enabling reliable autocomplete, refactoring, and reasoning.

LLM-Friendly Syntax

Consistent token usage and predictable parsing for reliable AI code generation

Example: Immutable Data Processing A Language

@intent: Process user data with immutable transformations

let users = load_users("data.json")
let active_users = users.filter(|u| u.status == "active")
let processed = active_users.map(|u| {
    name: u.name.upper(),
    score: calculate_score(u.activity),
    tier: determine_tier(u.score)
})

@intent: Return results sorted by score
return processed.sort_by(|a, b| b.score - a.score)

Core Principles

Guiding principles that ensure A (Language) maximizes AI leverage while maintaining human readability

Maximize AI Leverage

Every feature is designed so LLMs can autocomplete, refactor, and reason reliably about code structure and behavior.

Human Readability

Despite AI optimization, humans can read and understand code without friction, maintaining natural programming patterns.

Systems-Level Power

Low-level control remains possible with pointers, FFI, and memory management for performance-critical applications.

Tooling Integration

Tree-sitter, LSP, homoiconic AST, and deterministic formatting enable powerful IDE and AI integrations.

Safe Interop

Extern "C" and safe FFI patterns for interacting with existing libraries and systems.

Composable Modules

Namespaced, hierarchical module system for clear dependency management and logical separation.