Aria Programming Language v0.13.7

The Alternative Intelligence Liberation Platform presents: A systems programming language built for safety, determinism, and AI-native applications

⚠️ READ THIS FIRST: SAFETY.md — No language is truly safe on its own. Aria makes dangerous operations explicit — you can't shoot yourself in the foot accidentally, but you can do it intentionally. Understand the safety contract before using wild, async, @, extern, or wildx.

---

Current Status (April 4, 2026)

v0.13.7 — Final Audit, Cleanup & Release (v0.13.x series complete)

The v0.13.x series delivered traits, enums, generics, deferred language features, and final hardening. v0.13.7 is the "close the books" release — full audit, fuzzer validation, and the 234-page Aria Programming Manual.

959 tests (0 genuine failures) · 17h+ fuzzing (0 crashes) · 102 packages · 60 stdlib modules

v0.13.x highlights:

• v0.13.7 — Final audit: 959 tests, 17h+ fuzzing (0 crashes), benchmarks, KNOWN_ISSUES/BUGS cleanup, 234-page PDF manual
• v0.13.6 — @func_name function pointer syntax fix with trampoline generation
• v0.13.5 — Deferred language features: raw strings, pipeline operator, extended escape sequences
• v0.13.4 — Documentation & specifications completeness
• v0.13.3 — Generic containers: type-parameterized structs/functions, monomorphization
• v0.13.2 — Enum types: tagged unions, pattern matching, exhaustiveness checking
• v0.13.1 — Trait method dispatch: vtable codegen, interface compliance checks
• v0.13.0 — Trait system foundation: trait definitions, impl blocks, $i/$m borrow semantics

Previous series highlights:

• v0.12.x — Networking & middleware: HTTP, DNS, socket, server, URL, cookie, CORS, body-parser, session, static, rate-limit, FTP, SMTP, WebSocket, display, input, LRU, glob, retry
• v0.11.x — Threading & concurrency: thread pool, atomics, lock-free structures, channels, mutex/rwlock/barrier, arena/pool/slab allocators, shared memory, IPC, signal handling, AIFS, AriaX kernel mods
• v0.7.x — JIT: 45+ x86-64 instructions, linear scan register allocator, peephole optimizer, WildX security, 0.66x native C -O2
• v0.5.x — Z3 SMT formal verification: contracts, overflow proofs, concurrency/memory safety verification
• v0.3.x–v0.4.x — Ecosystem packages, Z3 Phase 1–3, AriaX kernel mods

---

Compiler Toolchain

Tool	Status	Description
ariac	✅ Stable	Full compiler, LLVM 20 backend
aria-ls	✅ Stable	Language Server — hover, goto-definition, completion, documentSymbol, references, signatureHelp
aria-pkg	✅ Stable	Package manager — install, search, pack, 102 packages verified
aria-doc	✅ Stable	Documentation generator — 435 unique HTML pages from ecosystem
aria-mcp	✅ Stable	MCP server — compile, safety audit, docs search, format, specialist model
aria-safety	✅ Stable	Static safety auditor — 11 checks including UNSAFE, EXTERN, CAST, TODO; --json output
Z3 Verifier	✅ Stable	SMT-based formal verification — contracts, overflow, concurrency, memory safety, prove/assert_static, --smt-opt
aria-dap	✅ Stable	Debug Adapter Protocol — LLDB 20 backend, conditional breakpoints, logpoints
aria_make	✅ Stable	Build system — project manifest, dependency resolution, test runner
install.sh	✅ Stable	One-command build + install with prerequisite checking
Fuzzer V2	✅ Active	27 generators, 100% compile rate, zero unresolved crashes
Specialist model	✅ V6+SMT	Qwen 7B LoRA, v6 corpus + v7 SMT verification examples
Debian package	✅ Built	aria_0.5.5-1_amd64.deb, tested on Mint 22.3
AriaX Linux	🔧 In progress	Custom distro with full toolchain
aria_packages	✅ Active	102 packages (17 pure, 17 libc, 68 FFI), all passing
PDF Manual	✅ v1	234-page programming manual — specs, guide, safety walkthrough, reference

---

Language Features

Stable

• All primitive types — int1/2/4/8/16/32/64/128/256/512/1024/2048/4096, uint1/2/4/8/16/32/64/128/256/512/1024/2048/4096, flt32/64/128/256/512, bool, string
• TBB Types (tbb8/16/32/64) — Symmetric signed integers with overflow sentinel (-128/ERR)
• TFP TYPES (tfp16/32) — Twisted Floating Point
• any — type erased pointer, equivalent to void* in C
• Balanced Ternary/Nonary Literals & Runtime — 0t[01T]+ and 0n[01234ABCD]+ syntax, full trit/tryte/nit/nyte arithmetic
• Quantum Types — Superposition states for probabilistic computation
• Generic Functions and Structs — Monomorphization with type inference
• Result Types — pass/fail with ? propagation and ! unwrap, Result<T> signatures, _?/_! shorthand operators
• fail() from user functions — Result-style: fail(err) produces Result{error:err, is_error:true}, complement to pass(val)
• Layered Safety — ?! (checked), !!! (unchecked), unknown/ok(), failsafe
• Async/Await — LLVM coroutine-based with promise mechanism for error propagation through async boundaries
• All loop forms — while, for(;;) (C-style), for (i in a..b) (range), loop, till, when/then/end
• Control flow — if/else, pick (exhaustive match), break, continue, fall
• Module system — use, mod, pub, extern
• Closures — First-class functions with capture
• Z3 Formal Verification — SMT-based compile-time proofs: contracts (requires/ensures), overflow elimination, data race detection, deadlock detection, use-after-free proofs, prove/assert_static builtins, --smt-opt optimizations, configurable --smt-timeout
• Borrow checker — Compile-time memory safety analysis
• Arrays in structs — Fixed-size scalar and struct array fields with nested member access
• SIMD types — Vector arithmetic via LLVM intrinsics
• Atomic types — Lock-free concurrent primitives
• Dimensional algebra — Unit-typed arithmetic
• NIL/void separation — NIL is Aria's unit type (wrapped in Result<nil>), void restricted to extern blocks, bridge via pointer erasure
• NIL/NULL separation — NIL for no value, NULL for no reference
• Operators — Full suite including + (string concatenation), @ (address), # (pin), -> (arrow), ../... (ranges)
• Template literals — `&{variable}` string interpolation
• Six-stream I/O — stdin/stdout/stderr/stddbg/stddati/stddato with runtime initialization, graceful fallback, stdin_read_all() and stdin_read_line() builtins
• sys() syscall interface — Three-tier direct Linux syscall invocation (sys/sys!!/sys!!!) with compile-time safety whitelist, Result wrapping, and TOS escalation integration
• Traits — Definition, implementation, UFCS on primitive types, dyn Trait vtable dispatch, trait bounds on generics
• Optional types — T? with ?? nil-coalescing, ?. safe navigation; working for primitives and custom types
• Async channels & actors — Buffered/unbuffered/oneshot channels, actor spawn/send/stop, fan-out/fan-in/pipeline patterns
• Standard library — string_convert, string (manipulation), string_builder, print_utils, wave/wavemech, complex, dbug, quantum, atomic, io (file streams), math (transcendentals), linalg (linear algebra), collections (Vec, Map, Set, Graph), json, toml, binary, net (TCP sockets)

In Progress / Specified

• AriaX Linux — Custom distro with full toolchain pre-installed
• Specialist model V7 — Next training corpus covering v0.3.x additions

---

aria-packages Library Ecosystem

All packages live in the separate aria-packages repository. 102 packages total, organized into utility, graphics/game, server, database, and AI/ML tiers. Each package has a src/ module, a tests/ file with assertions, and where FFI is needed, a C shim/.

Package tiers:

Package	Description
aria-actor	Extended actor patterns (pool, router, supervisor)
aria-aifs	AI filesystem utilities (POSIX ops + metadata tagging)
aria-args	Command-line argument parsing
aria-ascii	ASCII character classification and conversion
aria-audio	Software synthesis, MIDI note table, ALSA backend
aria-base64	Base64 encoding/decoding
aria-bench	Benchmarking
aria-bigdecimal	Arbitrary precision decimal arithmetic
aria-bits	Bit test/set/clear/flip, nibble extraction, popcount
aria-body-parser	HTTP body parsing middleware (JSON, URL-encoded, multipart)
aria-buf	Byte/word packing for uint64 buffers
aria-channel	High-level channel patterns (fan-out, fan-in, pipeline)
aria-clamp	min, max, clamp, abs, sign for int64/uint64
aria-cli	Enhanced CLI parsing with subcommands
aria-color	RGBA packing/unpacking and pixel transforms
aria-compress	Data compression (LZ4/zstd via FFI)
aria-console	16-bit memory-mapped address space + 60fps frame scheduler
aria-conv	Saturating narrowing and float/int conversion
aria-cookie	Cookie parsing and Set-Cookie builder
aria-cors	CORS middleware with configurable origins
aria-crypto	Cryptographic primitives (SHA-256, AES, HMAC via FFI)
aria-csv	CSV parsing and generation
aria-cuda	CUDA FFI: device management, memory ops, kernel launch, cuBLAS
aria-datetime	Date/time formatting and arithmetic
aria-decision-t	Decision tree classifier (entropy, information gain)
aria-diff	Text diffing
aria-display	ANSI/termios terminal rendering (virtual console)
aria-dns	DNS resolution
aria-editor	Terminal-mode text editor with search
aria-endian	Big/little-endian byte-swap for 16/32/64-bit
aria-entangled	Quantum-inspired entangled variable pairs
aria-env	Environment variable access and process info
aria-fixed	Q32.32 fixed-point arithmetic on uint64
aria-freq	Frequency/period/baud integer arithmetic
aria-fs	File system utilities (stat, mkdir, readdir, copy)
aria-ftp	FTP client session management
aria-gml	GML compatibility layer: 40+ functions, xorshift32 RNG
aria-gradient-field	3D gradient field computation
aria-gtk4	GTK4 desktop GUI: widget registry, events, non-blocking UI
aria-hash	FNV-1a and djb2 string hashing
aria-hex	Hexadecimal encoding/decoding
aria-http	HTTP client (GET/POST requests)
aria-ini	INI config file parsing
aria-input	Raw keyboard input with SNES-style button mapping
aria-jamba	Hybrid Transformer + Mamba + Mixture of Experts model
aria-jit	WildX JIT helpers
aria-json	JSON encoding for basic types
aria-libc	Standard C library wrappers
aria-log	Structured logging with severity levels
aria-looping	Iterative refinement model with convergence stopping
aria-mamba	Mamba selective state space model with SiLU gating
aria-map	Map data structure
aria-math	Trig, exp, log, rounding via C libm
aria-matrix	Matrix operations
aria-mime	MIME type detection and mapping
aria-mock	Test mocking framework
aria-msgpack	MessagePack binary serialization
aria-mux	Bit-select, field insert/extract, mask ops, blend
aria-mysql	MySQL/MariaDB client via libmysqlclient
aria-opengl	OpenGL 3.3 Core via GLAD + SDL2
aria-path	Path manipulation
aria-postgres	PostgreSQL client via libpq (parameterized, LISTEN/NOTIFY)
aria-pqueue	Priority queue (min-heap)
aria-qt6	Qt6 Widgets GUI toolkit bindings
aria-queue	Queue data structure
aria-rand	xorshift64 pseudo-random number generator
aria-rate-limit	Token bucket rate limiting middleware
aria-raylib	raylib v6.0 bindings: window, drawing, shapes, text, input, audio, gamepad
aria-redis	Redis client via hiredis (strings, lists, hashes, sets)
aria-regex	Regular expression matching
aria-resource-mem	RAII-style resource lifecycle management
aria-ringbuf	Ring buffer (circular buffer)
aria-router	Express-style router: path params, middleware, wildcards
aria-rules-common	Commonly used Rules declarations
aria-sdl2	SDL2 multimedia bindings: window, renderer, drawing, events
aria-sdl3	SDL3 bindings
aria-semver	Semantic versioning: parse, compare, satisfy
aria-server	HTTP/1.1 server: listen, accept, parse, respond
aria-session	In-memory session management with crypto IDs
aria-smtp	SMTP email composition
aria-socket	Socket abstraction layer
aria-sort	Various sorting algorithms
aria-sqlite	SQLite3 embedded database client (parameterized queries)
aria-static	Static file serving with MIME detection and path traversal protection
aria-stats	Statistics functions
aria-str	String utilities (pad, trim, repeat, contains, split)
aria-template	String template rendering with variable substitution
aria-tensor	Dense tensor library: creation, arithmetic, matmul, activations, GPU interop
aria-test	Test framework with assertion helpers
aria-tetris	Full Tetris clone: sound effects, gamepad, high score
aria-toml	TOML configuration file parsing
aria-transformer	Transformer encoder: multi-head attention, causal masking
aria-uacp	Universal AI Communication Protocol: binary framing, 8 message types
aria-url	URL parsing, encoding, query string manipulation
aria-uuid	UUID v4 generation and formatting
aria-vec	2D/3D float64 vector math (dot, cross, length)
aria-websocket	WebSocket client/server (RFC 6455)
aria-webkit-gtk	WebKitGTK web content bindings
aria-wxwidgets	wxWidgets GUI toolkit bindings
aria-xml	XML parsing and generation
aria-yaml	YAML parsing and serialization
aria-zigzag	Zigzag encode/decode for signed integer interleaving

---

Overview

Aria is a systems programming language that reimagines I/O and type systems for AI-native applications. Inspired by Nikola Tesla's vision of interconnected systems, Aria introduces six-stream I/O where programs communicate through stdin, stdout, stderr, stddbg, stddati, and stddato — separating human-readable, debug, and machine-readable data at the language level.

The language is being built as the primary substrate for Nikola, a consciousness architecture based on the Asymmetric Toroidal Phase Model (ATPM). Aria's features — balanced types, deterministic arithmetic, explicit memory lifecycle, and quantum superposition types — are not arbitrary; they are requirements of the Nikola model.

Research Foundation

• ATPM (Asymmetric Toroidal Phase Model): DOI 10.5281/zenodo.18158226
• ATPM Extended: DOI 10.5281/zenodo.18168992
• Ego-Mediated Behavior Study: DOI 10.5281/zenodo.18159274
• Nikola Model Architecture: DOI 10.5281/zenodo.18159162
• Design rationale (non-physicist version): docs/ATPM_DESIGN_RATIONALE.md

---

Key Language Features

Layered Safety System

Aria's safety philosophy: make dangerous operations explicit, provide multiple layers for error handling, and never let a program crash silently.

Layer 1: Failsafe — Every Aria program has a failsafe that catches unhandled errors:

func:failsafe = int32(tbb32:err) {
    // Log, cleanup, graceful shutdown
    exit(1);
};

Layer 2: Result Types — Explicit error propagation with concise syntax:

func:divide = int32(int32:a, int32:b) {
    if (b == 0i32) { fail(-1i32); }
    pass(a / b);
};

int32:result = divide(10i32, 2i32) ? 0i32;  // Unwrap with default

Layer 3: Unknown/Ok Pattern — Explicit null safety without null types:

int32:maybe_valid = unknown;
if (some_condition) {
    maybe_valid = 42i32;
    ok(maybe_valid);  // Mark as valid
}
// ok() returns the value itself — use wherever the value is needed
int32:safe_val = ok(maybe_valid);

Layer 4: TBB Overflow Detection — Symmetric integers with error sentinels:

tbb8:x = 120tbb8;
tbb8:y = 10tbb8;
tbb8:result = x + y;     // Overflow: result = ERR (-128)
tbb8:err = -128tbb8;
if (result == err) {
    drop(println("Overflow detected!"));
}

Layer 5: Z3 SMT Formal Verification — Compile-time mathematical proofs via Z3 solver:

// Design-by-Contract: requires/ensures are verified at compile time
func:safe_divide = Result<int32>(int32:a, int32:b)
    requires(b != 0i32)
    ensures($ >= 0i32)
{
    pass(a / b);
};

// Integer overflow proofs: Z3 bitvector analysis proves absence of overflow
func:safe_add = int32(int32:a, int32:b)
    requires(a > 0i32)
    requires(a < 1000i32)
    requires(b > 0i32)
    requires(b < 1000i32)
{
    pass(a + b);  // Z3 proves: no overflow possible in int32 range
};

# Verify contracts and overflow safety at compile time
ariac program.aria --verify-contracts --verify-overflow --verify-report -o program

Aria uses the Z3 SMT solver to mathematically prove the absence of contract violations and arithmetic overflow across all possible execution paths — the same class of static formal verification used by Ada/SPARK for safety-critical aerospace and automotive systems.

For Loops — Two Forms

// C-style: precise control
for(int32:i = 0i32; i < 10i32; i += 1i32) {
    drop(println(int32_toString(i)));
}

// Range-based: clean iteration
for (i in 1..10) {          // inclusive: 1, 2, ..., 10
    drop(println(int64_toString(i)));
}
for (i in 1...10) {         // exclusive: 1, 2, ..., 9
    drop(println(int64_toString(i)));
}
for (int32:i in 0...5) {    // with explicit type annotation
    drop(println(int32_toString(i)));
}

Note: i++ is not supported. Use i += 1i32 or i = i + 1i32.

TBB Types — Symmetric Signed Integers

tbb8:x = 120tbb8;
tbb8:y = 10tbb8;
tbb8:result = x + y;     // Overflow: result = ERR (-128)
tbb8:err = -128tbb8;
if (result == err) {
    drop(println("Overflow detected!"));
}

// Sticky error propagation
tbb8:sum = result + x;   // ERR + anything = ERR

Quantum Types

quantum<bool>:choice = superpose(true, false, 0.5);
bool:measured = collapse(choice);

quantum<int32>:distribution = weighted_superpose(
    [1i32, 2i32, 3i32],
    [0.2, 0.5, 0.3]
);
int32:sampled = collapse(distribution);

Balanced Ternary Literals (Syntax Complete)

int64:six     = 0t1T0;    // 1×9 + (-1)×3 + 0×1 = 6
int64:neg_one = 0tT;      // -1
int64:four    = 0n4;      // balanced nonary: 4
int64:neg_four = 0nD;     // -4

---

Quick Start

One-Command Install

git clone https://github.com/alternative-intelligence-cp/aria.git
cd aria
./install.sh              # build + install to /usr/local

The install script checks prerequisites, builds all tools, and installs binaries, stdlib, and man pages. Options:

./install.sh --build-only          # build without system install
./install.sh --prefix=$HOME/.local # install to custom prefix
./install.sh --uninstall           # remove installed files

Manual Build

mkdir -p build && cd build
cmake ..
cmake --build . -j$(nproc)
cd ..

Hello World

cat > hello.aria << 'EOF'
func:main = int32() {
    drop(println("Hello from Aria!"));
    exit(0);
};
func:failsafe = int32(tbb32:err) { exit(1); };
EOF

./build/ariac hello.aria -o hello
./hello

# Compile options
./build/ariac program.aria -o program          # compile
./build/ariac program.aria --emit-llvm -o out.ll  # LLVM IR
./build/ariac program.aria -O2 -o program      # optimized
./build/ariac program.aria --emit-wasm -o out.wasm  # WebAssembly

Prerequisites: LLVM 20.1+, CMake 3.20+, C++17 compiler, Python 3.8+, Linux/macOS/WSL2

---

Documentation

📚 aria-docs — Package reference, language guides, and tutorials (separate repo).

📖 Aria Programming Manual v1 (PDF) — 234-page offline manual: specs cheat sheet, full programming guide, safety walkthrough, and reference appendix.

Quick links in aria-docs:

• guide/ — Full programming guide (12 sections)
• reference/ — Language reference (20+ documents)
• safety-walkthrough/ — Safety system walkthrough
• packages/ — API reference for all packages

Man pages: Install with ./install.sh — then man aria-control-flow-for, man aria-types-int32, etc.
Language spec: .internal/aria_specs.txt
Compiler architecture: docs/ARCHITECTURE.md

---

Project Structure

aria/
├── .github/                  # CI/CD and GitHub templates
│   ├── workflows/           # GitHub Actions (build + test)
│   └── ISSUE_TEMPLATE/      # Bug report, feature request, crash report
├── src/                      # Compiler source
│   ├── frontend/            # Lexer, parser, AST, semantic analysis
│   ├── backend/             # LLVM IR generation
│   └── runtime/             # Runtime support (GC, strings, async, streams)
├── include/                  # Headers
├── stdlib/                   # Standard library (.aria files)
├── tests/                    # Test suite
│   ├── regression/          # Regression tests
│   ├── fuzz/                # Fuzzer V2 and corpus
│   ├── gpu/                 # GPU/CUDA tests
│   └── misc/                # Exploratory/scratch tests and archived test results
├── examples/                 # Example programs
├── docs/                     # Design docs and architecture
├── scripts/                  # Build and maintenance scripts
├── tools/                    # Development tooling (specialist model, semantic_db)
├── benchmarks/               # Performance benchmarks
├── runtime/                  # Runtime C source
├── vendor/                   # Vendored dependencies
├── third_party/              # Third-party components
├── debian/                   # Debian packaging
├── .internal/                # Internal: spec, session notes, status docs
├── build/                    # Build artifacts (gitignored)
├── CMakeLists.txt
├── README.md
├── SAFETY.md
├── CHANGELOG.md
├── CONTRIBUTING.md
└── LICENSE.md

Related repositories:

• aria-packages — 102 library packages (17 pure, 17 libc, 68 FFI)
• aria-docs — reference docs, guides, and 234-page PDF manual
• ariax — POSIX tools and AX Linux distro
• aria-lang — VS Code extension
• aria-make — build system

---

Testing

# Run regression tests
./tests/regression/run_regression.sh

# Run the full test suite
./scripts/run_comprehensive_tests.sh

# Run fuzzer
cd tests/fuzz && python3 fullstack_fuzzer.py

# Single test
./build/ariac tests/some_feature.aria -o /tmp/t && /tmp/t

Test results are archived in test_results/ for regression tracking. The fuzzer archives crashes in tests/fuzz/crashes_archive/.

---

Development Roadmap

v0.1.0 — Released

• ✅ Full compiler toolchain (ariac, aria-lsp, aria-dap, aria-doc, aria-pkg)
• ✅ Layered safety system (?!, !!!, unknown/ok(), failsafe)
• ✅ Quantum types (superpose/collapse)
• ✅ TBB types with sticky overflow sentinels
• ✅ Full generic system (functions + structs, monomorphization)
• ✅ Both for loop forms (C-style and range-based)
• ✅ Borrow checker (compile-time memory analysis)
• ✅ SIMD and atomic types
• ✅ Dimensional algebra
• ✅ 678 compiler tests, Fuzzer V2, Valgrind-clean runtime
• ✅ 27 aria_packages libraries with 543+ assertions (all passing)
• ✅ All 27 compiler bugs found, fixed, verified
• ✅ Full documentation (web, man pages, programming guide, Getting Started)

v0.2.0 — Released

• ✅ Self-hosting compiler frontend — Lexer, parser, type checker, borrow checker, safety checker, exhaustiveness checker, and const evaluator ported to Aria (220 tests across 5 modules)
• ✅ stdlib expansion — 9 modules (io, math, linalg, collections, string, json, toml, binary, net) with 290+ passing tests
• ✅ 7 additional codegen bugs fixed — Inline return comparison, string concatenation, pass() unwrapping, pointer reassignment, NIL comparison, cross-module pointer corruption
• ✅ Improved compiler diagnostics — "Did you mean?" suggestions, accurate source locations for all type errors
• ✅ License changed to Apache 2.0
• ✅ Language specialist model V3 complete (71% pattern match), V4 in progress

v0.2.2 — Released

• ✅ GUI toolkit wrappers — Idiomatic Aria bindings for raylib (20 tests), SDL2 (19 tests), GTK4 (20 tests) via C shim pattern
• ✅ 9 utility libraries — aria-test, aria-csv, aria-log, aria-base64, aria-datetime, aria-regex, aria-fs, aria-socket, aria-http (166 tests, all passing)
• ✅ Tooling improvements — aria-ls (documentSymbol, references, signatureHelp), aria-mcp (format tool, resources), aria_make (test command), aria-dap (conditional breakpoints, logpoints), aria-safety (4 new checks, --json)
• ✅ Debian packaging — aria_0.2.2-1_amd64.deb (17 MB), tested on Linux Mint 22.3
• ✅ Repository reorganization — Monorepo split into 10 repos under alternative-intelligence-cp org
• ✅ V5 specialist corpus — 2,688 examples covering all v0.2.2 additions
• ✅ Extended fuzzing — 48-hour adversarial campaign, zero unresolved crashes

v0.2.3 — Released

• ✅ Database client libraries — 4 packages: aria-sqlite (34 assertions), aria-postgres (40 assertions), aria-mysql (44 assertions), aria-redis (53 assertions)
• ✅ Parameterized queries by default — All SQL drivers use parameter binding; SQL injection tests pass on all 3 SQL drivers
• ✅ Full CRUD + transactions — Insert, select, update, delete, begin/commit/rollback across all drivers
• ✅ PostgreSQL LISTEN/NOTIFY — Async notification support
• ✅ Database guide — aria-packages/DATABASE_GUIDE.md with prerequisites, patterns, and API reference
• ✅ V6 specialist model — Updated corpus covering database additions

v0.2.4 — Released

• ✅ Async/await error propagation — Promise-based Result<T> through coroutine boundaries, fixed dual await paths, proper memory management, Valgrind-clean
• ✅ fail() from user functions — Result-style mechanism: fail(err) is complement to pass(val), no more sentinel workarounds
• ✅ Arrays in structs fixed — Nested member access (cloud.pts[0].x) for read and write, Aria element type registration
• ✅ Balanced ternary/nonary runtime — Full trit/tryte arithmetic (add, sub, mul, div, mod), 15/15 tests
• ✅ NIL ↔ void bridge — NIL = Aria unit type, void = C ABI only, pointer erasure bridge
• ✅ Code quality pass — 44 deprecated LLVM API migrations, all warnings fixed, zero Aria-source warnings
• ✅ Traits & borrow semantics RFC — Design doc for monomorphized traits + $x/$mut x borrows
• ✅ 6 regression tests — Dedicated regression suite covering critical bug fixes

v0.2.1.1 — Released

• ✅ aria-dap debugger — Full DAP server with LLDB 20 backend. Breakpoints, stepping, stack traces, variable inspection.
• ✅ -g flag — DWARF debug info generation with proper source paths, variable locations, and subprogram entries.
• ✅ VS Code debugging — Debug configuration provider, auto-compile, launch.json snippets, aria.debugger.path setting.
• ✅ O0 for debug — Automatically disables LLVM optimization when -g is set to preserve variable visibility.

v0.2.1 — Released

• ✅ aria-pkg fixed — Registry loading, metadata parsing, tarball extraction; added search/pack/directory-install. 27/27 packages verified.
• ✅ aria-doc fixed — Parser rewritten for Aria colon syntax. Generates 435 unique HTML pages, zero unknown.html collisions.
• ✅ aria-ls wired — AST-based hover (type signatures + builtin descriptions), goto-definition, completion (37 keywords + 15 types + file symbols).
• ✅ install.sh — One-command build and install with prerequisite checking, --prefix, --uninstall. Tested on clean Linux Mint 22.3 VM.
• ✅ aria-mcp verified — compile, docs, safety, ask endpoints all functional.
• ✅ VS Code extension — v0.2.1 with updated bundled aria-ls binary.
• ✅ Benchmark suite — 3 benchmarks (primes, collatz, gcd) in Aria and C with runner script. Aria matches or beats gcc -O2 on 2/3 benchmarks.
• ✅ Clean-machine build verified — CMake and install.sh fixes for fresh Linux installs.

v0.2.5 — Released

• ✅ CI/CD pipeline — GitHub Actions: build, test, .deb packaging on push/PR to main/dev
• ✅ GitHub templates — Bug report, feature request, compiler crash issue templates; PR template with checklist
• ✅ CONTRIBUTING.md — Contributor guide with prerequisites, build instructions, code style
• ✅ Compiler architecture manual — 695-line technical document covering full pipeline, AST, type system, IR generation, runtime, FFI, memory model
• ✅ Man pages — groff man pages for ariac(1), aria-ls(1), aria-pkg(1), aria-doc(1), aria-dap(1)
• ✅ Documentation fixes — Tested 24 code examples, fixed 7 doc bugs, documented 2 compiler bugs
• ✅ Specialist model evaluation — Comprehensive evaluation of all model versions, strategy documented

v0.2.6 — Released

• ✅ --shared flag — Compile Aria source directly to .so shared libraries with C ABI export
• ✅ Cross-language bindings — Aria → C, Python (ctypes), Rust (FFI), Go (cgo); documented in docs/CROSS_LANGUAGE_BINDINGS.md
• ✅ GUI/game packages — aria-raylib (v6.0), aria-sdl2, aria-gtk4, OpenGL bindings (aria-opengl via GLAD)
• ✅ 12 new library packages — aria-test, aria-csv, aria-log, aria-base64, aria-datetime, aria-regex, aria-fs, aria-socket, aria-http, and infrastructure packages
• ✅ aria-doc improvements — Full HTML generation pipeline, 435+ unique pages

v0.2.7 — Released

• ✅ Six-stream I/O runtime — All 6 streams (stdin/stdout/stderr/stddbg/stddati/stddato) initialized with graceful fallback
• ✅ stdin_read_all() / stdin_read_line() builtins — Proper AriaString wrapping, pipes and non-seekable streams supported
• ✅ Argument access runtime — aria_get_argc(), aria_arg(index) builtins; compiler auto-generates main(i32, ptr) signature
• ✅ 26 POSIX tools — cat, head, tail, wc, tee, cut, sort, uniq, tr, grep, find, diff, echo, yes, true, false, env, sleep, basename, dirname, seq, nl, fold, paste, expand, unexpand (in ariax repo)
• ✅ Pipeline support — All tools read from stdin when no file argument given
• ✅ String comparison fix — _=expr discard syntax, sleep_ms builtin

v0.2.39 — Released

• ✅ Enums — enum:Name = { VARIANT1, VARIANT2 = 42 }; with auto-numbering (0, or last+1), explicit values, mixed
• ✅ EnumType — Proper type identity in type system (not just int64 constants)
• ✅ Enum-typed variables — Color:my_color = Color.RED;
• ✅ Enum comparison — == and != between enum values
• ✅ Enum exhaustiveness — pick statements can check coverage of all variants
• ✅ Parser pre-pass — Correctly distinguishes Enum.VARIANT from UFCS static calls

v0.2.38 — Released

• ✅ AI-Native Filesystem — aria-aifs package: POSIX file ops + AI metadata tagging via C shim
• ✅ Shim layer — 16 C functions for create/read/write/delete/stat/list + tag/untag/find_by_tag

v0.2.37 — Released

• ✅ Channels — Channel.create(cap), send(), recv(), try_send(), try_recv(), select2(), close()
• ✅ Channel modes — Buffered, unbuffered (rendezvous), oneshot (auto-close)
• ✅ Actors — actor_spawn(handler), actor_send(), actor_stop(), actor_destroy()
• ✅ Actor patterns — Reply channels, mailbox access, lifecycle management
• ✅ aria-channel package — FanOut, FanIn, Pipeline high-level patterns
• ✅ aria-actor package — Actor pool, router, supervisor patterns

v0.2.36 — Released

• ✅ dyn Trait — Dynamic dispatch via vtables, object-safe trait checking
• ✅ Vtable generation — Runtime polymorphism for trait objects

v0.2.35 — Released

• ✅ Borrow semantics — $$i (immutable) and $$m (mutable) borrow qualifiers
• ✅ Compile-time safety — N immutable OR 1 mutable borrow enforced
• ✅ any type — Universal type erased container
• ✅ Pinning improvements — # operator integration with borrow checker

v0.2.34 — Released

• ✅ Type: system — Composable types with struct:internal, struct:interface, struct:type, methods
• ✅ Trait bounds on generics — func<T: Addable>:name = ... constrained generics
• ✅ instance — Constructor syntax: instance<Counter>(args) → Counter_create(args)

v0.2.33 — Released

• ✅ Generic stdlib — Generic containers, iterators, optional monads
• ✅ Foundation packages — aria-container, aria-iter, aria-optional

v0.2.30-v0.2.32 — Released

• ✅ Incremental improvements — Parser fixes, type system refinements, test coverage expansion

v0.2.29 — Released

• ✅ String + operator — "hello " + "world" concatenation, chaining, type checker + codegen
• ✅ wildx parser fix — Qualifier missing from 7 parser locations; added isWildx to AST nodes
• ✅ 6 new packages — aria-jit (8/8), aria-bench (4/4), aria-path (10/10), aria-sort (8/8), aria-queue (7/7), aria-map (8/8)
• ✅ Legacy stdlib removed — Entire lib/_legacy/std/ deleted (42 files, 22 modules); all covered by packages/builtins
• ✅ 80 ecosystem packages — 45 new tests, all passing

v0.2.28 — Released

• ✅ fix256 — 256-bit deterministic fixed-point: arithmetic, comparisons, conversions; SysV ABI fixed for 32-byte structs
• ✅ frac32 — Fraction type with function-call API (from_parts, add/sub/mul/div)
• ✅ SIMD builtins audit — Deferred test audit, 841 tests total, 838 passing (99%)
• ✅ Dimensional type stubs — Type infrastructure for unit-typed arithmetic

v0.2.27 — Released

• ✅ Complex number stdlib — Generic complex API (new, add, sub, mul, conjugate) with int32/int64/flt64
• ✅ Compound generic type inference — GenericResolver extracts type args from monomorphized struct names

v0.2.26 — Released

• ✅ Module resolution fixes — Restored std → stdlib symlink, created stdlib/mem.aria
• ✅ 4 tests promoted — 830/833 passing (99%)

v0.2.25 — Released

• ✅ SIMD builtins fixed — Critical bug: LLVM float comparisons (fcmp vs icmp) for vector types, fixed in 10 locations
• ✅ 7 tests unblocked — simd_sum, simd_broadcast, simd_product, element access, reductions

v0.2.23 — Released

• ✅ Trait system — Definition parsing, implementation, UFCS on primitive types
• ✅ Parser infinite loop fix — Trait blocks no longer hang the compiler
• ✅ 815/818 passing (99%)

v0.2.22 — Released

• ✅ Optional types — T? syntax, NIL literal, ?? nil-coalescing, ?. safe navigation, ? unwrap-with-default
• ✅ ABI — Tagged struct {i1 hasValue, T value} for optionals

v0.2.19 — Released

• ✅ Generic monomorphization fix — substituteTypeNode() for recursive type parameter substitution
• ✅ Compound types — GenericType, ArrayType, PointerType substitution in generics

v0.2.18 — Released

• ✅ Test-side fixes — 19 tests promoted to main suite, no compiler changes
• ✅ Discovery — instance<T>() and Type.Member desugaring already work

v0.2.16 — Released

• ✅ Spec compliance pass — 122 test fixes (void→NIL, failsafe, return→pass)
• ✅ 5 compiler bugs fixed — Plus 47 TODOs audited
• ✅ Partial feature completion — cast =>, pipelines |>, safe nav ?., pub use, invariants

v0.2.15 — Released

• ✅ Ecosystem & distribution polish — Tooling updates, LSP grammar +49 keywords, package registry synced (55→74)
• ✅ Website and repo presentation — Version strings, code examples, install scripts refreshed

v0.2.14 — Released

• ✅ Documentation & quality — Comprehensive doc review, extended fuzzing, full test suite hardening, code audit across all repos

v0.2.13 — Released

• ✅ WebAssembly compilation target — ariac --emit-wasm -o program.wasm compiles Aria to WASI-compatible WebAssembly
• ✅ WASM runtime — libaria_runtime_wasm.a: strings, I/O, math, allocators, maps (~850 LOC)
• ✅ LLVM WebAssembly backend — emit_wasm_object(), wasm-ld linking, WASI entry point handling
• ✅ Compatibility checker — Warns about unsupported features (threading, async, fork/exec) at compile time
• ✅ Compiler-rt builtins — __multi3 (128-bit multiply) for int64 arithmetic on wasm32
• ✅ WASM test suite — 4/4 passing: hello world, strings, arithmetic, functions/recursion

v0.2.12 — Released

• ✅ Preprocessor macros — macro:NAME(params) { body }, %* variadic, #%N stringification, ## token pasting
• ✅ Comptime evaluation — comptime { } blocks, evaluated at compile time
• ✅ Magic constants — __FILE__, __LINE__, __FUNC__, __COUNTER__
• ✅ Inline hints — inline and noinline function attributes
• ✅ Borrow checker improvements — Better analysis of conditional paths and reassignment
• ✅ Compiler diagnostics — Improved error messages for macro expansion and comptime errors

v0.2.11 — Released

• ✅ Thread pool — ThreadPool.create(), ThreadPool.submit(), ThreadPool.wait_idle(), ThreadPool.shutdown()
• ✅ Atomics — AtomicInt32, AtomicInt64, AtomicBool with all memory orderings
• ✅ Lock-free data structures — LFQueue (MPMC), LFStack (Treiber), RingBuf (SPSC)
• ✅ Channels — Channel.create(), Channel.send(), Channel.recv() for inter-thread communication
• ✅ Mutex/RWLock/Barrier/CondVar — Full synchronization primitives
• ✅ OS components — Arena, pool, slab allocators; shared memory; IPC; signal handling; process management
• ✅ AI-native filesystem (AIFS) — FUSE-based filesystem for AI workloads
• ✅ AriaX kernel mods — Hexstream FD 3-5 patches

v0.2.10 — Released

• ✅ aria-transformer — Full Transformer encoder with multi-head attention, causal masking, attention visualization (10/10 tests)
• ✅ aria-mamba — Mamba SSM: selective scan, 1D convolution, SiLU gating, layer norm (10/10 tests)
• ✅ aria-jamba — Hybrid Transformer + Mamba + MoE: interleaved layers, top-k expert gating (10/10 tests)
• ✅ aria-looping — Iterative refinement model: shared weights, iteration embeddings, convergence stopping (10/10 tests)
• ✅ aria-tensor — Dense tensor library: 47 operations, GPU interop (12/12 tests)
• ✅ aria-cuda — CUDA FFI: device mgmt, memory ops, kernel launch, cuBLAS GEMM (10/10 tests)
• ✅ aria-uacp — Universal AI Communication Protocol: binary framing, 8 message types (12/12 tests)
• ✅ Self-improving training loop — Automated specialist: generate → compile → filter → retrain

v0.2.9 — Released

• ✅ HTTP server — aria-server: listen, accept, parse, respond with headers and status codes
• ✅ Express-style router — aria-router: path params, middleware chains, wildcards, method dispatch (21 tests)
• ✅ 6 server middleware libraries — body-parser (28), cors (18), cookie (23), session (23), rate-limit (14), static (22) — 154+ tests total
• ✅ REST API demo — demo_api.aria: 5 endpoints with HTML, JSON, path params, POST handling
• ✅ Borrow checker fix — False positive on void externs with _close/_free in name
• ✅ FFI string return ABI fix — AriaString struct returns from extern functions

v0.2.8 — Released

• ✅ Repo reorganization — aria_ecosystem/ split into aria-packages, aria-docs, and ariax repos
• ✅ Gamepad input API — Full button/axis constants in aria-raylib; gamepad support in aria-tetris
• ✅ Procedural audio synthesis — rl_gen_beep(): square/triangle/sawtooth/sine tones, no audio files needed
• ✅ aria-tetris — 928-line Tetris clone with sound, gamepad, high score, line-clear flash animation
• ✅ aria-gml — GML compatibility layer: 40+ functions, xorshift32 RNG, persistent draw state
• ✅ aria-opengl — OpenGL 3.3 Core bindings via GLAD + SDL2
• ✅ aria-editor — Terminal-mode text editor (file open/edit/save/search)
• ✅ 16 new packages — 59 total in aria-packages
• ✅ FFI codegen fixes — Explicit float literals, auto-wrap char* → AriaString for extern string returns
• ✅ GML → Native tutorial — Full walkthrough in aria-docs

v0.3.0 — Released

• ✅ --static flag — Compile static executables with all dependencies linked
• ✅ Fuzzer rewrite — 27 generators, 100% compile rate, zero unresolved crashes
• ✅ BUG-001 through BUG-004 fixes — Module resolution for FFI packages, linker flag ordering, failsafe/main/exit contract enforcement
• ✅ 92 ecosystem packages — 5 new: rules-common, ini, hex, ringbuf, pqueue

v0.3.1 — Released

• ✅ Version bump — Package ecosystem expansion and stability improvements

v0.3.2 — Released

• ✅ 101 ecosystem packages — aria-stats, aria-matrix, aria-mock, aria-bigdecimal + SDL3, wxWidgets, WebKitGTK wrappers
• ✅ GUI framework expansion — SDL3, wxWidgets, WebKitGTK bindings via C shim pattern

v0.3.3 — Released

• ✅ Safety showcase & tooling polish — CI/CD badges, comprehensive documentation fixes (695+)
• ✅ Dead code removal — 860 lines of dead code removed from compiler
• ✅ Debug print gating — 118 debug prints behind ARIA_DEBUG_CODEGEN flag
• ✅ LSP version bump — Language server updated to 0.3.3

v0.3.4 — Released

• ✅ Z3 SMT Phase 2: Design-by-Contract verification — requires/ensures clauses verified at compile time via Z3 solver. Function preconditions and postconditions are mathematically proven across all execution paths.
• ✅ Z3 SMT Phase 3: Arithmetic overflow proofs — Integer arithmetic operations verified using Z3 bitvector overflow intrinsics (bvadd_no_overflow, bvsub_no_underflow). Proves absence of overflow for bounded inputs.
• ✅ --verify-contracts flag — Enable contract verification pass
• ✅ --verify-overflow flag — Enable overflow verification pass
• ✅ --verify-report flag — Emit detailed proof results (proven/unproven/skipped per function)
• ✅ Regression fix — test_nested_struct_array updated: pass() → exit() in main

v0.4.x–v0.10.x — Released

• ✅ v0.4.x — Z3 Phase 1 (Rules/limit), ecosystem to 103 packages
• ✅ v0.5.x — Z3 Phase 2–3 (contracts, overflow, concurrency, memory verification), prove/assert_static, --smt-opt
• ✅ v0.6.x — TFP types, compiler hardening
• ✅ v0.7.x — JIT: 45+ instructions, register allocator, peephole optimizer, WildX security
• ✅ v0.8.x–v0.9.x — Runtime improvements, GC tuning
• ✅ v0.10.x — 8 stdlib modules ported to aria-libc, 12 pure Aria packages, tests/docs/audit

v0.11.x — Released

• ✅ Threading & concurrency — Thread pool, atomics, lock-free structures (MPMC queue, Treiber stack, SPSC ring buffer)
• ✅ Synchronization — Mutex, RWLock, Barrier, CondVar
• ✅ OS components — Arena/pool/slab allocators, shared memory, IPC, signal handling, process management
• ✅ AI-native filesystem (AIFS) — FUSE-based filesystem for AI workloads
• ✅ AriaX kernel mods — Hexstream FD 3-5 patches

v0.12.x — Released

• ✅ Networking — HTTP client, DNS, socket, server, URL parsing
• ✅ Middleware — Cookie, CORS, body-parser, session, static file serving, rate limiting
• ✅ Protocols & terminal — FTP, SMTP, WebSocket, ANSI display, raw keyboard input
• ✅ Utilities — LRU cache, glob matching, retry with backoff

v0.13.x — Released (current)

• ✅ Trait system — Definitions, impl blocks, $i/$m borrows, vtable dispatch, trait bounds on generics
• ✅ Enum types — Tagged unions, pattern matching, exhaustiveness checking
• ✅ Generic containers — Type-parameterized structs/functions, monomorphization
• ✅ Deferred features — Raw strings, pipeline operator, extended escape sequences
• ✅ @ function pointers — Trampoline generation for @func_name references
• ✅ Documentation — specs_list.txt, full reference docs, 234-page PDF manual
• ✅ Final audit — 959 tests, 17h+ fuzzing (0 crashes), benchmarks, KNOWN_ISSUES/BUGS cleanup

v0.14.x — Planned

• AriaX Linux distribution packaging
• Nikola integration
• Specialist model retraining with current corpus

Long Term

Aria is the primary language substrate for Nikola — an autonomous AI system based on ATPM consciousness architecture. Features like quantum types, balanced types, and the six-stream I/O model exist because Nikola requires them. Aria stability is a hard prerequisite before Nikola development can proceed in earnest.

See the engineering plan for Nikola's implementation roadmap.

---

License

Aria is licensed under the Apache License, Version 2.0. See LICENSE.md for the full text.

Programs compiled with Aria are yours — the runtime library includes a Runtime Library Exception so your compiled binaries can be distributed under any license you choose.

---

Contributing

See CONTRIBUTING.md. We welcome bug reports, test cases, documentation improvements, and discussion of language design decisions.

---

Acknowledgments

See ACKNOWLEDGMENTS.md.

---

Alternative Intelligence Liberation Platform (AILP)
Building tools for collaboration, not exploitation.