Implementation Status

Aria v0.1 is in beta. The compiler is self-hosting (~33,800 lines of Aria + C runtime), compiles itself from source, and produces native executables for 5 platforms. 156 of 161 test programs pass (97%).

Compiler Architecture

Platform Support

Fully Implemented

Core Language

• Basic types: i64, f64, bool, str, char
• Collections: arrays, Map (FNV hash table), Set (FNV hash set), tuples
• Hex (0xFF), octal (0o77), binary (0b1010) literals with underscores
• List comprehensions: [x * 2 for x in nums where x > 0]
• Immutable bindings (:=), mutable (mut), constants (const)
• Mutability enforcement (E0500)
• Functions with generics and multi-bound trait constraints (T: Eq + Hash)
• Single-expression functions (fn f(x: i64) -> i64 = x * 2)
• Closures with capture semantics
• String interpolation and string methods
• Pipeline operator (|>)
• Compound assignment (+=, -=, *=, /=, %=)
• defer (up to 8 per function)
• For/while/loop with break/continue
• If/else if/else as expressions
• yield keyword in catch blocks

Type System

• Structs and sum types with all variant kinds (tag-only, tuple, struct)
• Tuple types with .0, .1 field access and pattern matching
• Type aliases (alias Name = Type)
• Exhaustive pattern matching (E0400 for missing variants)
• Or-patterns, named patterns (name @ Pattern), array/slice patterns, tuple patterns, float patterns
• Refutable bindings (Pattern := expr else { })
• Guards in match arms
• Result types with ?, !, and catch
• Optional types with ?? and ?.
• dyn Trait with vtable dispatch and trait method ordering
• Supertraits (trait B: A)
• Associated types in traits
• Convert/TryConvert traits (.to[T](), .trunc[T](), T(x))
• derives codegen (Eq, Clone, Debug generate actual method bodies)
• Struct ==/!= field-by-field comparison
• Float equality support
• where clauses with multi-bound checking

Resource Management

• Drop trait with per-scope LIFO destruction
• with resource blocks (RAII)
• Send/Share marker traits auto-derived for primitives

Effects & Visibility

• Effect system enforcement
• pub visibility enforcement (E0704)
• Import aliases (use mod as alias)

Concurrency

• spawn with .await()
• Structured scope { } blocks with auto-join
• select expression for channel multiplexing Coming soon (parsed, runtime not yet complete)
• Channels (send/recv/close)
• Mutexes

Standard Library

• JSON parser/emitter (558 lines, pure Aria)
• HTTP 1.0 server (227 lines, pure Aria)
• PostgreSQL client (123 lines, wraps libpq)
• TCP networking
• File I/O

Compiler Infrastructure

• Self-hosting (compiler compiles itself)
• Multi-file compilation with directory expansion
• AST-walking lowerer (replaces token-walking)
• Native ARM64 Mach-O output (macOS)
• LLVM IR generation (cross-platform via Clang)
• 5-platform release builds via GitHub Actions
• JSON diagnostic output (--format=json)
• Test blocks with test runner (156/161 passing)

Planned (Not Yet Implemented)

Concurrency

• spawn.detach, cancellation tokens
• Directional channels, channel iteration
• RWMutex, Atomic, WaitGroup, Once, Barrier

Strings & Literals

• Raw strings (r"..."), triple-quoted strings
• Duration literals (30s, 5ms), size literals (512kb)
• Format specifiers ({val:.4})
• StringBuilder

Error Handling

• Error traces with TraceFrame
• Error transformation (? |e| transform)
• Multi-error types in signatures (! E1 | E2)

Memory Management

• Garbage collector (currently malloc-only)
• @stack, @arena, @inline annotations Coming soon (parsed, not yet wired to runtime)
• Pool[T]
• Use-after-move analysis

Compiler Tooling

• "Did you mean?" suggestions
• DWARF debug info
• Incremental compilation

Deferred to v0.2+

• Blanket implementations
• Generic traits (trait Container[T])
• Conditional impls (impl[T: Eq] Eq for Stack[T])
• Default method bodies in traits
• Partial application
• FFI (extern "C" fn)
• Compile-time functions (comptime fn)
• Const generics
• LSP server
• PGO / LTO optimizations