Nitpick Changelog

Tests: - bug256 round-trip alloc/deref/free through HandleArena. - bug257 compile-fail Handle -> Handle. - bug258 use-after-free deref returns NULL (no UB). - bug259 arena destroy invalidates outstanding handles to it. - tests/bugs/run_bug_tests_0278.sh + CTest entry bug_tests_v0278.

Deviations from PLAN spec: - No generic dispatch (Arena.alloc(a)); used HandleArena.alloc(a, size). - Stale-deref policy is NULL on deref (matches v0.27.7 ABI), not panic. - No K test: pure FFI wrapper, K does not model extern.

Validation: ctest 69/69 (was 68), K core 151/151, K proofs 11/11.

v0.27.7

Released: 2026-05-15 19:15:32 -0400

v0.27.7: Handle Phase 1 — runtime ABI + generation counters

New npk_handle_* C ABI under include/runtime/handle.h and src/runtime/allocators/handle_alloc.cpp. 64-bit packed handle [generation:32 | arena_id:16 | slot_index:16]; generation 0 reserved for NPK_HANDLE_NULL; live slots start at gen 1 and saturate at UINT32_MAX (saturated slots are retired, never recycled, so generations never wrap to a re-issuable value).

Operations: npk_handle_arena_create() / _destroy(arena) npk_handle_alloc(arena, size) -> npk_handle_t npk_handle_deref(h) -> void* (NULL on stale / null / destroyed-arena) npk_handle_free(h) (no-op on stale / null / destroyed-arena)

All four operations are mutex-serialised; calloc-backed slot data is freed on explicit free or on arena destroy. Wired into RUNTIME_SOURCES so every Aria executable links the new symbols.

Tests: tests/runtime/test_handle_v0277.cpp covers bug252-bug255 (alloc/deref roundtrip, UAF caught at deref, 65 536-cycle generation churn, arena_destroy invalidates outstanding handles). Wired as CTest runtime_handle_v0277 (labels memory;handles;runtime;v0.27.7).

No K test — runtime layer only; the Aria-side surface and matching K model arrive in v0.27.8.

Validation: ctest 68/68, K core 151/151, K proofs 11/11.

v0.27.6

Released: 2026-05-15 16:54:48 -0400

v0.27.6: codify wild + borrow-checker interop (bug249-251, K151)

Verification slice — no compiler code changes. v0.27.1 (region tags on every binding) and v0.27.2 (borrow-region inheritance) already made i/m borrows of wild bindings go through the regular borrow checker. This slice locks that behaviour in with regression tests and documents it as PLAN.md option (b).

bug249 — $$i borrow on a wild binding compiles and runs. bug250 — overlapping $$m borrows on a wild buffer rejected (ARIA-023). bug251 — wild buffer through $$i/$$m parameters works end-to-end. K-151 — wild + scoped $$i + free triple in the K semantics.

CTest 66 -> 67, K core 150 -> 151, all PASS.

v0.27.5

Released: 2026-05-15 15:16:45 -0400

v0.27.5: wildx W^X lifecycle (bug245-248)

Make the wildx keyword first-class by exposing the W^X state machine through three pointer-keyed surface builtins:

wildx_alloc(size: int64) -> wildx int8@ // W mapping wildx_seal(ptr: int8@) -> int32 // W -> X transition wildx_free(ptr: int8@) -> int32 // munmap, registry erase

The runtime keeps a process-wide unordered_map<void*, WildXGuard> (mutex-guarded) that owns the FNV-1a hash, ASLR jitter, quota accounting, and state machine. Surface code only ever holds a plain int8@; the guard struct stays in the runtime.

Frontend - type_checker_call.cpp: type the three builtins (size, ptr, ptr). - codegen_expr_call.cpp: lower to npk_wildx_alloc / _seal / _free. - borrow_checker.cpp: register wildx_alloc as an allocator alongside alloc/npk_alloc/malloc so the wild-leak checker still fires; add wildx_free to KNOWN_DEALLOCATORS so ARIA-022 catches double-free.

Runtime (src/runtime/allocators/wildx_alloc.cpp) - npk_wildx_alloc: wraps npk_alloc_exec, registers ptr -> guard. - npk_wildx_seal: registry lookup -> npk_mem_protect_exec; rc=-1 on miss (the existing state-machine guard already rejects double-seal). - npk_wildx_free: registry pop -> npk_free_exec; rc=-1 on miss (catches double-free / foreign-pointer misuse from below the borrow checker). - All failure paths print a [WildX] panic: line to stderr.

Hardware MMU still enforces write-after-exec via SIGSEGV; the runtime only adds the registry-level seal/free invariants on top.

Tests (CTest 65 -> 66, all PASS) - bug245: full alloc -> seal -> free round-trip. - bug246: second wildx_seal returns -1 (one-way W -> X). - bug247: double wildx_free statically rejected (ARIA-022). - bug248: wildx_alloc without cleanup statically rejected.

Wired as bug_tests_v0275 in tests/CMakeLists.txt.

Legacy form wildx int8->:b = alloc(N); free(b); (bug016/100) still parses and routes through plain wild allocator; migration to the new triple is opt-in.

Docs: REPOS/aria-docs/guide/memory/wild.md wildx section rewritten from “parsed for symmetry” to a full lifecycle walkthrough.

PLAN: META/NITPICK/ROADMAP/0.27/PLAN.md v0.27.5 marked DONE.

v0.27.4

Released: 2026-05-15 09:53:09 -0400

v0.27.4: pin address-stability K proof (PIN-DEC-004 part 1)

Closes the K-side of PIN-DEC-004 (deferred from v0.26.3.4): formal proof that the address of a pinned gc binding is invariant under any sequence of garbage-collector cycles in the K model.

k-semantics/aria.k: - Add gc_cycle ; statement syntax (Stmt production). - Add a no-op rewrite rule <k> gc_cycle ; => .K ... </k> that touches no other configuration cell. This encodes the runtime invariant that the collector does not relocate pinned objects: , , and are preserved across a cycle.

k-semantics/proofs/pin-address-stable-proofs.k (new, 11th proof): - Module ARIA-PIN-ADDRESS-STABLE-PROOFS with three kprove claims: 1. gc_cycle ; preserves , , . 2. <- PINPTRLOC(L) after gc_cycle ; reads the same V from L (the core address-stability lemma). 3. Two consecutive gc_cycle ; reductions still preserve the pin cell (induction step generalising to any finite sequence).

Validation: - K proofs 10/10 -> 11/11 (run_k_proofs.sh ~2m). - CTest 65/65 PASS (no regression, ~5m).

Deferred to a follow-up slice (bug244): - Part 2 of PLAN.md v0.27.4 (concurrent-collector runtime stress with NPK_GC_MODE=concurrent + worker-thread harness + 10k alloc/safepoint cycles). The K lemma above is the formal property; the runtime stress is separate plumbing. Precedent: v0.18.4 KLEE Phase 5 was likewise deferred.

v0.27.3

Released: 2026-05-15 00:16:11 -0400

v0.27.3: ARIA-031 STACK_REF_INTO_GC_FIELD diagnostic

v0.27.2

Released: 2026-05-14 23:58:20 -0400

v0.27.2: ARIA-029 GC_REF_FROM_WILD diagnostic + region-aware hint

v0.27.1

Released: 2026-05-14 23:36:32 -0400

v0.27.1: var_regions refactor on LifetimeContext

v0.26.7

Released: 2026-05-14 15:00:28 -0400

v0.26.7 — v0.26.x cycle close

Cycle-boundary tag at the v0.26.6 commit (2c1018c). v0.26.7 itself is documentation-only on aria-docs (9-chapter memory cookbook + cycle audit + RELEASE_0.26.7); no aria source/test changes.

Closes the v0.26.x GC & Stack Memory Deep Dive cycle.

Final validation gates (carried over from v0.26.6): CTest 108/108 pass K core 150/150 pass K proofs 10/10 pass

Cycle audit: META/NITPICK/ROADMAP/done/0.26/AUDIT_v0.26.x.md Release doc: META/NITPICK/ROADMAP/done/0.26/RELEASE_0.26.7.md

v0.26.6

Released: 2026-05-14 15:00:28 -0400

v0.26.6: ARIA-028 STACK_ESCAPE polish (MEM-014, partial)

Rename and rephrase the stack/return-borrow escape diagnostic. Pre-v0.26.6 the compiler tagged these errors ARIA-017 while the docs (guide/borrow/diagnostics.md) promised ARIA-027 for the same concept; v0.26.6 unifies both onto ARIA-028 STACK_ESCAPE, matching the v0.26.0 master plan.

borrow_checker.cpp changes (two narrow sites):

• checkReturnBorrowEscape: when a pass/fail/return value is an identifier whose loan_origins include a host at depth > 1, the message now reads Cannot return borrow R it points into local binding H, whose stack frame is destroyed when the function returns with a suggestion-line hint: return by value, take ownership in the caller, or accept a borrow parameter and return that
• checkBlockStmt outlives detection: similarly rephrased to … outlives its host hosts stack frame ends here.

Both sites now tagCode(ARIA-028). Internal control flow and the K-semantics escape rules are unchanged. The K model already abstracts the stack-escape rule under its borrow-lifetime cells; renaming a tag is a surface-level change on the C++ side.

Tests:

• bug232: pass via fail (escape through the fail path which goes through checkFailStmt checkReturnBorrowEscape).
• bug233: borrow taken in an inner if-block, passed from outer scope.
• bug234: message-quality grep asserts the diagnostic mentions ARIA-028, stack frame, the host name, and the borrower name.
• bug235: positive case internal-only borrow compiles + exits 0.
• run_bug_tests_0266.sh + ctest bug_tests_v0266 (label memory;diagnostics;ARIA-028;MEM-014;v0.26.6) wires all four.
• run_bug_tests_0261.sh: pre-existing v0.26.1 stack-escape suite (bug205bug208) re-tagged ARIA-017 ARIA-028; header comment updated to note the v0.26.6 retag.

Decisions / scope:

• ARIA-029 GC_REF_FROM_WILD and ARIA-031 STACK_REF_INTO_GC_FIELD (renumbered from the originally-planned ARIA-030, which is already used by the await borrow runtime warning checked in run_bug_tests_0256.sh) both deferred to v0.26.6.1. They require per-binding region tracking in LifetimeContext (currently only var_depths is recorded), a wider refactor than this polish slice.

Validation: ctest –output-on-failure 108/108 pass bash run_k_tests.sh 150/150 pass bash run_k_proofs.sh 10/10 pass bash run_bug_tests_0261.sh 5/5 pass (retagged) bash run_bug_tests_0266.sh 4/4 pass (new)

v0.26.5

Released: 2026-05-14 14:24:12 -0400

v0.26.5: MEM-013 wild/wildx ↔︎ GC interop verified

Two MEM-013 invariants from the v0.26.0 master plan, both already enforced by the runtime as of v0.26.0; the slice closes the verification + tests + docs gap and ships one ABI-safe accessor.

Invariant 1: GC marker never traces into wild memory. Both trace loops in gc.cpp (lines 771, 834) gate on is_heap_pointer(ref), which checks nursery and old-gen address ranges. wild allocations (npk_alloc -> libc malloc) live outside both ranges and are silently skipped.

Invariant 2: wild slots do not root anything. npk_alloc never touches the shadow stack; only gc bindings push roots (wired in v0.26.3.2). The narrow escape hatch when a wild slot must root a gc reference is npk_shadow_stack_add_root, present since the v0.26.3.x shadow-stack work and now documented.

Runtime change: new int32_t npk_gc_is_heap_pointer_i32(void*) in include/runtime/gc.h + src/runtime/gc/allocator.cpp. The existing bool npk_gc_is_heap_pointer returns C _Bool (1 byte AL); SysV x86-64 leaves the upper EAX bits undefined, so reading it through a Nitpick int32 extern produces garbage (observed during bug230 development as exit codes 3, 22, 99, 111 instead of 0/1). The new accessor is fully-extended and safe from Nitpick code. Existing C callers of the bool variant are unaffected.

Tests: - tests/bugs/bug230_gc_wild_heap_partition.npk: verifies the partition primitive returns 1 for #h (gc Holder) and 0 for npk_alloc(64) in the same scope. - tests/bugs/bug231_gc_wild_coexist_under_churn.npk: verifies a gc Holder survives 5000 npk_alloc(128)/npk_free/churn(Trash)/ npk_gc_safepoint() cycles. - tests/bugs/run_bug_tests_0265.sh: driver, mirrors the v0.26.4 pattern minus the env-var setup. - tests/CMakeLists.txt: bug_tests_v0265 (label memory;gc;interop;MEM-013;v0.26.5).

No K-semantics change: the K model abstracts the heap as a flat region and does not distinguish gc from wild. Modelling the partition would require a region tag on every allocation site and is not a 0.26.x slice. No new ARIA diagnostic this slice; GC_REF_FROM_WILD and STACK_REF_INTO_GC_FIELD are the v0.26.6 / MEM-014 work.

Validation: CTest 107/107, K core 150/150, K proofs 10/10. Docs: aria-docs guide/memory/interop.md (new chapter, ships in parallel commit).

v0.26.4

Released: 2026-05-14 12:06:24 -0400

v0.26.4 — MEM-011/012 GC tuning env-vars + tuning.md

Read NPK_GC_NURSERY_SIZE, NPK_GC_OLD_GEN_THRESHOLD, NPK_GC_MODE in GCState::init() with explicit-args > env > default precedence. NPK_GC_MODE=concurrent flips on the SATB background mark thread; stw is the default; off is documented as deferred.

New public C accessors npk_gc_nursery_size_bytes, npk_gc_old_gen_threshold_bytes, and npk_gc_concurrent_enabled expose the resolved configuration to user code and to the regression fixtures.

Tests bug226-bug229 spawn fresh subprocesses (env -i) so the GC singleton observes the env-var on first init. Wired as ctest bug_tests_v0264 (label memory;gc;tuning;MEM-011;v0.26.4).

Validation: CTest 61/61, K core 150/150, K proofs 10/10.

v0.26.3.4

Released: 2026-05-14 08:16:44 -0400

v0.26.3.4 (sub-series closeout): K core 149/150 (pin × gc combo)

K-semantics gap closure for the v0.26.3.x sub-series. Existing pin tests (051..067) all use stack values; existing alloc-region tests (146..148) cover gc/stack region selection but never combine with pinning. Two new core tests close the combo:

149_pin_gc_pass.aria — gc int32:x = 42; int32->:p = #x; exit <-p; expect 42. Combines test 146 (gc region) with test 061 (pin deref). The exact path that v0.26.3.{1,2,3} made first-class. 150_pin_gc_mut_borrow_failsafe.aria — same setup, then attempts $$m int32:ref = x while pin alias is live; expect failsafe (exit 7). Mirrors test 054 for the gc region.

K core 150/150 (was 148). K proofs 10/10 (held — pin_address_stable.k deferred per PIN-DEC-004; modelling npk_gc_safepoint precisely needs collection-cycle abstraction in the K runtime model, target v0.27.x).

aria-docs guide/memory/regions.md “What is coming” rewritten in a parallel commit (nitpick-docs main b3e51c7): v0.26.3 entry no longer mentions deferral; new v0.26.3.x entry describes closed work with example block.

Sub-series 0.26.3 is now CLOSED. AUDIT_v0.26.3.x.md consolidates the five-slice arc; do not roll v0.26.3.5+ unless a regression forces a hot patch. Next active cycle: v0.26.4 (MEM-011/012 GC tuning knobs).

v0.26.3.3

Released: 2026-05-14 07:44:58 -0400

v0.26.3.3 (MEM-010 closeout): reinstate gc safepoint + pin alias tests

Closes the MEM-010 deferral originally noted in v0.26.3. The auto-pin + shadow-stack root tracking shipped in v0.26.3.2 made it safe for a gc binding (and any pin alias derived from it via #x) to survive a real npk_gc_safepoint()-driven collection. This slice reinstates that guarantee as two execution-level fixtures.

bug224 — gc Holder:h survives 5000 churn() iterations interleaved with explicit npk_gc_safepoint(); h.value still reads as the original sentinel afterwards. No borrow, no pin alias. bug225 — same shape, but uses wild Holder->:p = #h; and reads through the pin alias p->value. Verifies that #h returns a working pointer that the safepoint loop does not stale.

Wired as ctest bug_tests_v02633 (label memory;gc;pin;safepoint; MEM-010;v0.26.3.3, timeout 120s). 60/60 ctest.

Files: tests/bugs/bug224_gc_survives_explicit_safepoint.npk (new) tests/bugs/bug225_gc_pin_alias_survives_safepoint.npk (new) tests/bugs/run_bug_tests_02633.sh (new) tests/bugs/run_bug_tests_0263.sh (docstring) tests/CMakeLists.txt (register)

v0.26.3.2

Released: 2026-05-14 02:01:28 -0400

v0.26.3.2 (GCRT-001..005): wire shadow-stack root tracking for gc bindings

Each function with at least one gc binding now lazily emits npk_shadow_stack_push_frame at the first binding. Each gc binding pins the heap object (so the SSA pointer stays valid across minor GCs) and registers a stack-slot root via npk_shadow_stack_add_root. The frame is popped after defers on every RETURN/PASS/FAIL exit and on fall-through return at function end (top-level fn, impl method, trait method).

Before this slice, gc bindings were heap-allocated (per v0.26.3.1) but invisible to the mark phase, so the next minor GC would either evacuate them out from under the SSA pointer or sweep their old-gen copy. Compiled Aria code never called any of the npk_shadow_stack_* runtime APIs even though those wrappers had been sitting in src/runtime/gc/allocator.cpp the whole time.

GCRT-DEC-001: pin + slot-of-pointer (NOT alloca-and-reload). The SSA heap pointer remains the working value; pinning guarantees it never goes stale, so MEMBER_ACCESS lowering needs no changes.

Known limitation: ~10 special-case CreateRet sites in coroutine glue and contract-error paths are not instrumented; this leaks shadow frames at process-end only (no memory corruption, no UB).

Tests: ctest 59/59 (added bug_tests_v02632 with bug223_gc_survives_ collection.npk; 4 IR checks + 1 exec check that 200k garbage allocs do not invalidate the gc-rooted binding).

v0.26.3.1

Released: 2026-05-14 00:20:00 -0400

v0.26.3.1: honor allocation qualifiers (gc/wild/stack); delete dead StmtCodegen

Root cause: IRGenerator::generate_var_decl emitted CreateAlloca unconditionally, silently ignoring the gc/wild/stack qualifiers. A parallel class StmtCodegen contained the correct three-way switch but was never instantiated (ExprCodegen.stmt_codegen was always nullptr). Every gc/wild binding ended up on the stack with no GC visibility and no heap allocation – a critical safety-critical correctness gap masked by the dead-code path appearing correct.

Fix: * Inline three-way switch into IRGenerator (ir_generator.cpp ~4935): - isGC -> npk_gc_alloc(size, type_id=0) returning ptr - isWild -> npk_alloc(size) returning ptr - else -> CreateAlloca(varType) Debug-info insertDeclare and explicit alignment guarded behind alloca_inst, since heap returns are not AllocaInst*. Opaque-pointer LLVM 20 makes the heap/stack swap drop-in for downstream GEPs.

• Delete src/backend/ir/codegen_stmt.cpp (3189 lines) and include/backend/ir/codegen_stmt.h (354 lines). Backup retained at META/NITPICK/ROADMAP/0.26/0.26.3.x/_dead_code_backup/. Removed from CMakeLists.txt with explanatory comment. Removed StmtCodegen forward decl, stmt_codegen member, and setStmtCodegen from ExprCodegen header + .cpp. Replaced dead lambda-body branch in codegen_expr_compound.cpp:990 with always-emit-terminator block. Dropped four stale codegen_stmt.h includes.

• Regression tests (bug_tests_v02631):

  • bug220_gc_emits_npk_gc_alloc.npk – IR must contain %h = call ptr @npk_gc_alloc
  • bug222_stack_emits_alloca.npk – IR must contain %h = alloca %Holder
  • bug221_wild_emits_npk_alloc.npk – in-tree but SKIPPED; full runnable test deferred to v0.27 wild ergonomics (type system never promotes wild value-type bindings to pointer types, so free(h) and ARIA-014 leak check have no satisfiable form today). IR-level wire-up verified by manual inspection.

Validation: 58/58 ctest pass, build clean, no behavioural regression on any prior fixture.

Repositioning of subsequent slices: * v0.26.3.2 (NEW): GC root registration audit – now that gc bindings actually hit the heap, verify shadow-stack tracing. * v0.26.3.3-7: original v0.26.3.1-5 pin lowering plan, renumbered. * v0.27 (REPOSITIONED): wild ergonomics + bug221 reinstatement. * v0.28: wildx + JIT (unchanged).

v0.26.3.0

Released: 2026-05-13 20:54:43 -0400

v0.26.3.0: PIN baseline fixtures (PIN-001/002/003/004)

Lock in current behavior of the #x pin operator before the lowering work scheduled for v0.26.3.{1..5}. No compiler changes in this slice.

• bug217: #stack_x baseline (PIN-DEC-001 — stays no-op forever).
• bug218: #gc_x baseline today; pin lowering arrives in v0.26.3.{2,3} but the .npk source itself stays unchanged.
• bug219: ARIA-016 rejects $$m borrow of pinned gc binding (negative).
• run_bug_tests_02630.sh + CTest entry bug_tests_v02630.

Confirmed npk_gc_pin/npk_gc_unpin/npk_gc_safepoint already linked in build/npkc (PIN-004). Audit doc: META/NITPICK/ROADMAP/0.26/0.26.3.x/PIN_LOWERING_AUDIT.md.

CTest: 57/57 (was 56/56).

v0.26.3

Released: 2026-05-13 14:04:01 -0400

v0.26.3: GC borrow + safepoint interaction (MEM-009); MEM-010 pin syntax deferred

• bug213: $$m borrow of gc survives an explicit npk_gc_safepoint() call.
• bug214: $$m borrow of gc survives a 5k-iteration churn + safepoint loop (drives implicit minor collections via nursery pressure).
• bug215 (negative): ARIA-023 still fires for double $$m borrow of a gc binding – borrow rules apply uniformly across stack/gc regions.
• Wired as bug_tests_v0263 (label memory;gc;borrow;MEM-009;v0.26.3).

MEM-010 (pin syntax #x -> npk_gc_pin/unpin) DEFERRED: runtime entry points exist (allocator.cpp:337,341) and gc.h documents the intended wild T@:ptr = #gc_obj spelling, but the compiler does not yet lower the # operator. There is also no & address-of operator, so the runtime pin entry points are currently unreachable from Aria source. Tracked in CODEGEN_AUDIT.md item 4; slated for a follow-up slice.

CTest 56/56.

v0.26.2

Released: 2026-05-13 13:37:59 -0400

v0.26.2: GC stress smoke (MEM-006/007/008) + npk_gc_alloc type_id passthrough

• codegen now declares and calls npk_gc_alloc(size, type_id=0i16) matching the runtime ABI (was 1-arg, eliminating latent garbage type_id bug on x86-64 SysV where RSI was read uninitialized)
• bug210: 50k small gc allocations (nursery rollover stress)
• bug211: 5k large (8 x int64) gc allocations (old-gen path)
• bug212: long-lived holder survives 30k churn allocations
• Wired as bug_tests_v0262 (label memory;gc;MEM-006;MEM-007;MEM-008;v0.26.2)

CTest 55/55.

v0.26.1

Released: 2026-05-13 11:45:11 -0400

v0.26.1: stack-escape regression suite (MEM-005, bug205-209)

Confirms ARIA-017 already detects stack-escape across direct, chained, and struct-field borrow paths; conservatively rejects gc-local borrow returns too. Adds bug205-209 plus run_bug_tests_0261.sh wired into CTest as bug_tests_v0261 (label memory;MEM-005;v0.26.1).

CTest 54/54.

v0.26.0

Released: 2026-05-13 11:35:15 -0400

v0.26.0: memory model docs + codegen audit + K core tests 146-148 (MEM-001/002/003)

First slice of v0.26.x (GC & Stack Memory Deep Dive). Documents the actual default-region behavior (default = stack, not gc) and locks it in with three K core baseline tests.

Validation: CTest 53/53, K core 148/148, K proofs 10/10.

v0.25.7

Released: 2026-05-13 10:34:44 -0400

v0.25.7: K core tests 143-145, guide/borrow/, audit + closeout (BORROW-014)

Cycle close for v0.25.x (Borrow Checker Hardening). All 14 BORROW-* items resolved.

Validation: CTest 53/53, K core 145/145, K proofs 10/10.

See AUDIT_v0.25.7.md for the full cycle audit.

v0.25.6

Released: 2026-05-13 09:55:10 -0400

v0.25.6: closure capture + multi-await + diagnostic polish (BORROW-011, BORROW-012, BORROW-013)

BORROW-011 (closure capture borrow tracking): - TypeChecker FUNCTION_TYPE early-return now invokes analyzeLambda before defineSymbol so capturedVars is populated for closures assigned to function-typed variables. - ClosureAnalyzer BINARY_OP handler detects TOKEN_EQUAL with identifier LHS as a mutation (Aria parses plain x = expr as BinaryExpr, not AssignmentExpr). Added PASS / FAIL walkers as well. - BorrowChecker checkVarDecl now records reference loans via recordBorrowWithPath(AccessPath(cap.name), borrower, true, stmt) for every BY_REFERENCE capture in a lambda initializer; BY_MOVE captures go into ctx.moved_variables. - recordBorrowWithPath is required (not legacy recordBorrow) so the loan path base matches the captured variable, allowing checkPathConflict to reject subsequent m/i borrows on the captured variable with ARIA-023.

BORROW-012 (multi-await polish): - Verified existing checkAwaitExpr already walks active_loans on each await and emits ARIA-030 per live mutable loan.

BORROW-013 (ARIA-023/026 secondary spans): - Verified existing checkBorrowRulesWithPath / path-conflict diagnostics already emit secondary location text for the prior borrow.

Tests bug200-204 + run_bug_tests_0256.sh + CMake target bug_tests_v0256 (labels borrow;BORROW-011;BORROW-012;BORROW-013;v0.25.6). CTest 53/53.

v0.25.5

Released: 2026-05-12 22:39:21 -0400

v0.25.5: two-phase borrows + impl mut self (BORROW-009, BORROW-010)

BORROW-009: fix UFCS method-call param-index off-by-one in checkCallOwnership. expr->arguments did not include the implicit receiver but summary.param_ownership[0] was self (m), soarguments[0] = 7i32wascheckedagainstm self and rejected ARIA-020. Added a defaulted param_offset arg; UFCS dispatch in checkCallExpr passes 1 to skip the implicit self slot. Two-phase activation falls out naturally because no self-loan is registered for the call duration.

BORROW-010: $$m self in trait impls already worked via path-tracker (BORROW-005) + auto-receiver-borrow logic; locked in by tests.

Tests bug195-199, runner run_bug_tests_0255.sh, CMake target bug_tests_v0255 (labels borrow;BORROW-009;BORROW-010;v0.25.5). CTest 52/52.

v0.25.4

Released: 2026-05-12 20:08:23 -0400

v0.25.4: inter-procedural borrow summaries (BORROW-007, BORROW-008)

BORROW-007: checkCallOwnership now extracts AccessPath for MEMBER_ACCESS, POINTER_MEMBER, and INDEX argument expressions and conflict-checks them via LifetimeContext::checkPathConflict, so m/i call args participate in path-sensitive ARIA-023. mutable_borrow_targets is keyed by full base:path to prevent silent aliasing of two $$m args.

BORROW-008: FunctionBorrowSummary gained return_borrow_source_param. buildSummary infers it (single-borrow-parameter heuristic). checkVarDecl borrow-init branch now handles CALL initializers: peeks through raw / drop , looks up the callee summary, extracts the source-arg AccessPath, and registers the new borrow at that host via recordBorrowWithPath. Multi-borrow-parameter callees emit a clear cannot-infer ARIA-023.

Type-checker borrow-init guard relaxed to admit CALL initializers. Tests bug190-194 + run_bug_tests_0254.sh + bug_tests_v0254 CMake target. CTest 51/51, branch dev-0.25.x.

v0.25.3

Released: 2026-05-12 19:36:47 -0400

v0.25.3: deep struct paths verified + ptr->field borrow paths (BORROW-005, BORROW-006)

BORROW-005 (deep struct paths): unified AccessPath already chains MemberAccessExpr to N levels; verified end-to-end with bug184 (3-level disjoint), bug185 (parent/child reject), bug186 (deep writeback).

BORROW-006 (ptr->field borrows): parser produces POINTER_MEMBER NodeType, not MEMBER_ACCESS, so the type checker rejected ptr->field borrow init as non-addressable. Fixes:

• type_checker_stmts.cpp: add POINTER_MEMBER case to isAddressableBase + accept POINTER_MEMBER in top-level borrow-init guard.

• borrow_checker.cpp extractAccessPath: handle POINTER_MEMBER, push “->field” segment so pointer-deref paths are distinct from value-paths.

• borrow_checker.h isDisjointFrom: conservative cross-pointer aliasing – two paths with a “->…” segment under different base_vars are NOT disjoint (escape analysis deferred to BORROW-007/008). Same-pointer ptr->x vs ptr->y still disjoint.

Tests bug184-189, runner run_bug_tests_0253.sh, CTest bug_tests_v0253 (labels borrow;BORROW-005;BORROW-006;v0.25.3). CTest 50/50.

v0.25.2

Released: 2026-05-12 16:22:13 -0400

v0.25.2: multi-dim & nested array borrow paths verified (BORROW-004)

BORROW-004 verified DONE: extractAccessPath already chains MEMBER_ACCESS+INDEX and AccessPath::isDisjointFrom already disjoints distinct literal segments. Behavior locked via regression tests bug179-183 (bug_tests_v0252). No borrow-checker code changes needed. CTest 49/49.

v0.25.1

Released: 2026-05-12 15:18:13 -0400

v0.25.1: defer body + early-exit borrow release (BORROW-002, BORROW-003)

Phase 0: fix type-checker ICE on DEFER body (NodeType 40) by adding TypeChecker::checkDeferStmt. Phase 1 (BORROW-002 partial): BorrowChecker::checkDeferStmt now recurses into the defer block in its own scope so intra-body borrow conflicts are caught (ARIA-023). Phase 2 (BORROW-003): added checkForLeaksAllScopes() and wired it into pass/fail/return + exit() call interception so wildx leaks on early exit are flagged (ARIA-014). Tests: bug175-178 + run_bug_tests_0251.sh (bug_tests_v0251). CTest 48/48.

v0.24.7

Released: 2026-05-12 10:12:26 -0400

v0.24.7: reflection, K semantics, guide/comptime/, audit + closeout

v0.24.6

Released: 2026-05-11 22:28:19 -0400

v0.24.6: limit comptime + comptime limitations (COMPTIME-011, COMPTIME-012)

v0.24.5

Released: 2026-05-11 21:54:07 -0400

v0.24.5: comptime generics — type:T parameters (COMPTIME-010)

• Parser: accept type keywords as bare call args; parse type:T parameter syntax
• AST: ParameterNode.isTypeParam flag
• ConstEvaluator: ComptimeValue::Kind::TYPE_NAME with operator==/< support
• ConstEvaluator: MEMBER_ACCESS evaluation for @typeInfo(T).bit_width
• ConstEvaluator: type-arg resolution lambda binds T identifier to type name
• TypeChecker: register type-param funcs without resolving param types; emit diagnostic when type: appears in non-comptime function (COMPTIME-010 gate)
• TypeChecker: skip assignability check for type-param argument positions
• TypeChecker: int32/int64/etc. recognized as primitive type expressions
• IRGen + codegen_stmt: skip IR generation for type-param funcs (intrinsics like @typeInfo cannot be lowered)
• Tests: bug164 (typeInfo bit_width), bug165 (@sizeof + assert_static), bug166 (negative: type: requires comptime); CTest bug_tests_v0245
• Validation: 3/3 v0.24.5 bug tests pass; full ctest suite green (k_semantics_proofs isolated pass 118s; flakes under parallel only)

v0.24.4

Released: 2026-05-11 21:16:31 -0400

v0.24.4: assert_static+comptime + error diagnostics (COMPTIME-008, COMPTIME-009)

v0.24.3

Released: 2026-05-11 20:53:04 -0400

v0.24.3: macro × comptime interaction (COMPTIME-006, COMPTIME-007)

v0.24.2

Released: 2026-05-11 20:26:05 -0400

v0.24.2: @sizeof, @alignof, @len, comptime string ops (COMPTIME-003, 004, 005)

v0.24.1

Released: 2026-05-11 19:53:28 -0400

v0.24.1: loop() + mutable locals in CTFE (COMPTIME-001, COMPTIME-002)

v0.24.0

Released: 2026-05-11 13:33:08 -0400

Merge dev-0.23.x: v0.23.x cycle complete (MACRO-001–013, 12/13 resolved)

v0.23.7

Released: 2026-05-11 13:33:00 -0400

v0.23.7: –expand-macros flag (MACRO-012), K semantics (MACRO-013), guide docs, regression tests, audit

v0.23.6

Released: 2026-05-11 09:58:50 -0400

v0.23.6: built-in macros assert!/todo!/unreachable!/cfg! (MACRO-008..011)

• Added built-in macro dispatch in inferMacroInvocation()
  • assert!(cond) -> AssertStaticStmt(cond)
  • todo!(…) -> guaranteed runtime-failing assert fallback
  • unreachable!() -> guaranteed runtime-failing assert fallback
  • cfg!(pred) -> compile-time bool literal
• Added strict cfg! predicate validation with unsupported-key errors
• Reserved built-in macro names in checkMacroDecl (cannot redefine)
• Parser support for cfg!(…) in expression and statement positions
• Added v0.23.6 regression suite (bug137-141)
• Wired bug_tests_v0236 into CTest labels

Validation: - v0.23.6 targeted: 5/5 pass - full CTest: 38/38 pass

v0.23.5

Released: 2026-05-11 03:24:40 -0400

v0.23.5 Phase 2: defer MACRO-007, clarify scope and next steps

• MACRO-006 (statement macros) is complete and tested
• MACRO-007 (code-generating macros) deferred due to architecture constraints
• Code-gen macros require program-level invocations and hoisting infrastructure
• MACRO-007 planned for v0.23.6 or later
• Updated test comments to document scope clearly

v0.23.4

Released: 2026-05-11 01:35:08 -0400

v0.23.4: variadic macro declarations and arity checks (MACRO-005)

• AST: extend MacroDeclStmt with variadic metadata
  • isVariadic flag
  • restParamName string
• Parser: parse variadic macro rest syntax as ..?rest
  • enforce rest parameter must be last
• Type checker:
  • non-variadic macros keep exact arity behavior
  • variadic macros enforce minimum arity (fixed params only)
  • bind rest args into substitutions via ArrayLiteralExpr(rest…)
• AST toString includes variadic marker in MacroDecl rendering
• Add tests/bugs/run_bug_tests_0234.sh:
  • bug130 variadic-only macro accepts 0/1/3 args
  • bug131 fixed+rest accepts base arg and extras
  • bug132a too-few variadic arity error
  • bug132b rest-not-last parse error
• Wire bug_tests_v0234 into CTest

Validation: - macro-focused CTest: 6/6 pass - full CTest: 36/36 pass

v0.23.3

Released: 2026-05-11 01:22:12 -0400

v0.23.3: recursive macro expansion + depth guard (MACRO-004)

• cloneAST: add MACRO_INVOCATION clone path so nested macro calls survive AST cloning
• inferMacroInvocation: add thread-local expansion depth guard (limit 64) with clear compile error for runaway recursion
• add regression runner tests/bugs/run_bug_tests_0233.sh:
  • bug127 nested macro calls
  • bug128 deeper nested call chain
  • bug129 infinite recursion depth-limit failure
• wire bug_tests_v0233 into tests/CMakeLists.txt

Validation: - macro-focused CTest: 5/5 pass - full CTest: 35/35 pass

v0.23.2

Released: 2026-05-10 23:49:28 -0400

v0.23.2: macro hygiene fix (MACRO-003)

• Restore clean v0.23.1 baseline for type checker/header/main
• Implement hygienic renaming in cloneAST block cloning:
  • gensym local VarDecl names to __macro__
  • remap subsequent identifier uses within block scope
  • preserve lexical scoping via scoped substitution map copies
• Add regression runner: tests/bugs/run_bug_tests_0232.sh
  • bug124: macro-introduced tmp no longer clobbers caller tmp
• Wire bug_tests_v0232 into tests/CMakeLists.txt

Validation: - macro subset: 4/4 pass (macro_smoke_compile/run, bug_tests_v0231, bug_tests_v0232) - full suite: 34/34 pass

v0.23.1

Released: 2026-05-10 17:27:27 -0400

v0.23.1: basic macro pipeline regression tests (MACRO-001, MACRO-002)

• bug121a: 1-param expression macro (double_it!) — correct output
• bug121b: 2-param expression macro (add!) — correct output
• bug121c: 0-param macro (answer! = 42) — correct output
• bug121d: macro result used in larger expression — correct output
• bug122a: too many args → “expects 1 arguments, got 2” at call site
• bug122b: too few args → “expects 2 arguments, got 1” at call site
• bug123a: undefined macro name → “Undefined macro ‘nope’”
• bug123b: duplicate macro declaration → “already defined”
• CTest: 33/33 pass (bug_tests_v0231, macro_smoke_compile, macro_smoke_run)

MACRO-001 and MACRO-002 confirmed working — pipeline and call-site error reporting both correct. No regressions.

v0.23.0

Released: 2026-05-10 13:06:23 -0400

v0.23.0: macro triage — wire smoke test into CTest (MACRO-001)

• Audited macro pipeline end-to-end: parse→checkMacroDecl→inferMacroInvocation→cloneAST→expandedAST→codegen
• MACRO-001 (basic pipeline): WORKING — test_macro_basic.npk passes
• MACRO-002 (call-site errors): WORKING — wrong arg count points to call site
• MACRO-003 (hygiene): GAP — cloneAST keeps varName verbatim, no gensym
• MACRO-004 (recursive): GAP — cloneAST has no MACRO_INVOCATION case, returns nullptr
• MACRO-005 (variadic): NOT IMPLEMENTED
• MACRO-006 (statement position): WORKING
• MACRO-007..013: NOT IMPLEMENTED
• Wired macro_smoke_compile + macro_smoke_run into CMakeLists (label: macros,MACRO-001,v0.23.0)
• CTest: 32/32 pass

See META/NITPICK_MACROS/MACROS.md for full triage notes.

v0.22.7

Released: 2026-05-10 08:18:18 -0400

Merge dev-0.22.x: v0.22.x cycle complete (POLISH-001–014, 13/14 resolved)

v0.22.6

Released: 2026-05-10 03:30:39 -0400

v0.22.6: POLISH-008 — reserved keyword diagnostics in parser

v0.22.5

Released: 2026-05-10 02:10:08 -0400

v0.22.5: POLISH-009 — and escape sequences in strings

Add hex and unicode escape sequence support to all three string scanners in the Nitpick lexer (scanString, scanCharacter, template literal scanner).

escape: - Exactly 2 hex digits (0-9, a-f, A-F) decoded to a single byte value - Works in regular strings, character literals, and template literals - Error on non-hex digit or fewer than 2 digits

escape: - 1-6 hex digits inside {} decoded to a Unicode codepoint - Encoded as UTF-8 in the output string (1-4 bytes per codepoint) - Works in regular strings and template literals - Errors: missing {}, non-hex digit, 0 digits, codepoint > U+10FFFF

Existing escapes unchanged: " \0

Regression tests: - bug117: in strings and template literals (hex A-F, a-f, 0xFF) - bug118: ASCII (U+41), 2-byte (©), 3-byte (€), 4-byte (😀) - bug119: error cases — , 234, all produce clear errors

CTest: 27/27 (bug_tests_v0225: 5/5)

v0.22.4

Released: 2026-05-10 00:01:58 -0400

v0.22.4: POLISH-006+007 — pick on integers, bitwise ops on variables

POLISH-006: pick statement on integer selector values — verified working. - pick(int32:v) with literal i32 arm patterns and wildcard (*) — correct dispatch - pick(int64:v) with large 64-bit literal arms — correct dispatch - No compiler changes needed; feature was already fully implemented - Regression tests: bug114_pick_int32.npk, bug115_pick_int64.npk

POLISH-007: bitwise operators on int32 and uint8 runtime variables — verified working. - All 5 operators on int32 variables: & | ^ >> << — correct values - All 3 bitwise operators on uint8 variables: & | ^ — correct values - Variable-operand paths through IR generator and codegen are correct - No compiler changes needed; shim workaround in chip8 was unnecessary caution - Regression test: bug116_bitwise_vars.npk

CTest: 26/26 (bug_tests_v0224 = 3/3)

v0.22.3

Released: 2026-05-09 20:09:23 -0400

v0.22.3: POLISH-003+011 — get_argc/get_argv builtins, break/continue

POLISH-003: get_argc() and get_argv(i) builtins for CLI arg access. - args.c: add npk_get_argc_builtin() (returns g_argc-1, excludes program name) and npk_get_argv_cstr(i) (returns argv[i+1] as char*, or “” if OOB) - type_checker_call.cpp: register get_argc (returns int32, 0 args) and get_argv (takes int32, returns string) as builtins - type_checker_stmts.cpp: add get_argc/get_argv to reservedBuiltins set - codegen_expr_call.cpp: get_argc -> call npk_get_argc_builtin (i32); get_argv -> call npk_get_argv_cstr + getOrDeclareStringFromCstr() - npk_arg() marked deprecated (ABI-broken: returns pointer, not value) - Regression: bug112_get_argc_argv.npk

POLISH-011: break and continue in loop bodies — already implemented; tests added. - Parser, AST nodes, type checker, borrow checker, IR generator, and codegen all handle BreakStmt/ContinueStmt correctly (verified via smoke tests). - break exits while/loop to afterloop block; continue skips to next iteration. - Error on break/continue outside loop is caught at IR gen time. - Regression: bug113_break_continue.npk (while+break = 21, loop+continue = 42)

CTest: 25/25 (bug_tests_v0223 = 3/3)

v0.22.2

Released: 2026-05-09 16:04:00 -0400

v0.22.2: POLISH-001+002+010 — eprint/eprintln, .aria ext, struct type identity

POLISH-001: eprint() and eprintln() builtins wired end-to-end. - type_checker_call.cpp: recognise eprint/eprintln as builtins returning int64 - type_checker_stmts.cpp: add eprint/eprintln to reserved-builtin set - codegen_expr_call.cpp: route to npk_eprint_cstr / npk_eprintln_cstr (stderr) - stdlib.cpp: add npk_eprint_cstr and npk_eprintln_cstr (write() to STDERR_FILENO) - Regression: bug109_eprint_eprintln.npk

POLISH-002: .aria file extension accepted by module resolver. - module_resolver.cpp: isValidAriaFile() accepts .npk or .aria; tryFindModule() tries .aria variants after .npk for both search patterns - module_table.cpp: extension list now includes .aria - Error message updated: “not a .npk/.aria file” - Regression: bug110_aria_extension.npk + bug110_aria_ext_module.aria

POLISH-010: struct type identity across multi-module imports. - Root cause: preRegisterFunctions() runs before use-imports are processed. resolveTypeNode(“Foo”) fell through to getPrimitiveType(“Foo”) which creates a fake PrimitiveType(“Foo”) in the cache. Later, when the use-imports ran, StructType(“Foo”) was added, but the function symbol still held PrimitiveType(“Foo”). Call-site checks then reported “Foo but expects Foo”. - Fix: in checkFuncDecl(), when the existing symbol was pre-registered from the same FuncDeclStmt pointer (i.e. same AST node), update its type in-place with the freshly-resolved types rather than calling defineSymbol() (which would fail as duplicate). - Regression: bug111_struct_type_identity_multimod.npk + modA/modB helpers

CTest: 25/25 (bug_tests_v0222 = 3/3)

v0.22.1

Released: 2026-05-09 15:44:33 -0400

v0.22.1: POLISH-012+014 — unused-var checker fixes (while body, pass stmt)

v0.22.0

Released: 2026-05-09 15:26:03 -0400

v0.22.0: POLISH triage — 14 entries from chip8/jsmn/brainfuck ports; no code changes

v0.21.6

Released: 2026-05-09 02:48:27 -0400

v0.21.6: K semantics — tbb8/tbb16/tbb64 + async/await (A-009, A-010)

• aria.k: add tbb8/tbb16/tbb64 type lattice (Val, normalize, arithmetic)
• aria.k: add async func: syntax + loadFuncs rules (0/1/2 param)
• aria.k: add await rules (synchronous model — Result unwrap + owise)
• K tests 128-136: tbb8/tbb16/tbb64 arithmetic + ERR sentinel (9 tests)
• K tests 137-139: async/await (3 tests) => K core 127 -> 139/139
• bug105: tbb8/tbb16/tbb64 compiler regression test (exit 0)
• bug106: async func: / drop compiler smoke test (exit 0)
• run_bug_tests_0216.sh: bug105 + bug106 runner (2/2 pass)
• CMakeLists.txt: bug_tests_v0216 CTest entry (#24) => 24/24
• SEMANTIC_GAPS.md: document remaining unformalized constructs
• AUDIT_v0.21.6.md: cycle-close audit
• KNOWN_ISSUES.md: A-009/A-010 partially addressed, test suite updated

CTest: 24/24 K core: 139/139 K proofs: 10/10 Bug tests: 2/2

v0.21.5

Released: 2026-05-08 19:04:31 -0400

v0.21.5: A-011 verified (ahset auto-grow), A-012 floor regression, KNOWN_ISSUES updates, bug103-104 + CTest entry

v0.21.4

Released: 2026-05-08 16:09:42 -0400

v0.21.4: AArch64 JIT error (A-005), ir_generator ICE messages (A-006/A-007), DAP setExceptionBreakpoints (A-015), ABI docs

v0.21.3

Released: 2026-05-08 15:05:52 -0400

v0.21.3: ICE message quality (A-008), pick int32/int64 range exhaustiveness (A-013), KNOWN_ISSUES updates

v0.21.2

Released: 2026-05-08 14:14:57 -0400

v0.21.2: async borrow checking (A-003, ARIA-030), Rules/Z3 index disjointness (A-004)

v0.21.1

Released: 2026-05-08 13:40:28 -0400

v0.21.1: cfg conditional compilation, derive(Display), preprocessor hardening, catch diagnostic

A-001: cfg conditional compilation - parseAttributes() handles TOKEN_KW_CFG with nested predicate collection - evaluateCfgPredicate(): target_os, target_arch, target, feature, debug, release, not(), any(), all() against host platform via C++ macros - nodeHasFalseCfg(): skips FUNC/STRUCT/ENUM with false cfg in checkStatement() and in preRegisterFunctions() struct + function pre-passes

A-002: derive(Display) - Auto-generates impl:Display:for:T with TemplateLiteralExpr body - format: “StructName { field1: &{self.field1}, field2: &{self.field2}, … }” - Explicit impl:Display:for:T override still works (no duplicate impl error)

A-014: catch keyword diagnostic - parseStatement() detects TOKEN_KW_CATCH and emits a clear parse error directing users to “defaults”, “?”, “!!”, or “pick” instead

Preprocessor hardening - ConditionalState.has_else field prevents %elif-after-%else and duplicate %else - %define redefinition warning (different value) - %undef of undefined symbol warning - %include missing-file error lists searched paths

Tests: bug082-bug088 (7/7 pass), preprocessor suite 22/22 pass CTest: 19/19 passed, 0 failures

v0.21.0

Released: 2026-05-08 13:10:42 -0400

v0.21.0: spec gap audit — 15 findings, no compiler changes

v0.20.5

Released: 2026-05-08 11:51:25 -0400

Merge dev-0.20.x: v0.20.0-v0.20.5 complete

v0.20.4

Released: 2026-05-08 11:06:17 -0400

v0.20.4: Closure lifetime validation, optional safe navigation type fix

• closure_analyzer.cpp: fix isFromOuterScope() (resolveSymbol + GLOBAL/MODULE check); implement validateLifetimes() with double-aliasing detection
• type_checker.h / type_checker.cpp: wire ClosureAnalyzer into LAMBDA handler
• borrow_checker.h / borrow_checker.cpp: add checkLambdaExpr(); emit ARIA-025 ERROR on escape, WARNING on pass-to-function for BY_REFERENCE captures
• type_checker_expr.cpp: STRUCT and POINTER ?. paths now return optional (getOptionalType(field.type)) instead of bare field type
• tests/closures/: 3 tests + run script (CTest #16)
• tests/optional/: 2 tests + run script (CTest #17)
• docs/CLOSURE_GUIDE.md, docs/OPTIONALS_GUIDE.md: new
• KNOWN_ISSUES.md: remove “Lambda closures do not capture scope” entry

CTest: 17/17 pass

v0.20.3

Released: 2026-05-08 08:28:58 -0400

v0.20.3: Const Evaluator Step 7 — struct/array comparison, pass/VAR_DECL in comptime bodies, raw unwrap, literal type normalization, non-integer store/deref, memoization complete

v0.20.2

Released: 2026-05-08 02:53:48 -0400

v0.20.2: Template Literals & Display trait — struct/enum Display in interpolation, actionable error for missing impl, 23-test suite

v0.20.1

Released: 2026-05-08 01:25:56 -0400

v0.20.1: preprocessor hardening — %error, %warning, %str() directives + 16-test suite

New preprocessor directives: - %error “msg”: aborts compilation with a user-defined message (respects conditional branches) - %warning “msg”: emits a build warning to stderr, continues compilation - %str(content): inline stringify directive — replaces with “content” as string literal

No-op inside inactive conditional blocks (false %ifdef/%if branches).

New test suite (tests/preprocessor/run_preprocessor_tests.sh, 16 tests): - Regression: %define/%undef, %ifdef/%ifndef, %if/%elif/%else, %rep/%endrep, %assign, %push/%pop, include guard, multi-arg macros, nested conditionals - New: %warning fires + message in output, %error in active branch aborts, %error in false branch skipped, ## token paste, #%N stringify, %str()

CTest: 13/13 tests passed (12 pre-existing + preprocessor_tests)

v0.20.0

Released: 2026-05-08 00:47:35 -0400

v0.20.0: diagnostics hardening — UNUSED_FUNCTION, EMPTY_BLOCK warnings, IR/TC ICE messages, template literal error quality, IMPLICIT_CONVERSION no-op cleanup

v0.19.5

Released: 2026-05-07 22:52:20 -0400

v0.19.5: audit, docs, KNOWN_ISSUES update, 4 new regression tests (bug078-081)

v0.19.4

Released: 2026-05-07 19:53:54 -0400

v0.19.4: K semantics update — dyn-index borrows, struct update, pick struct pats, lambda vars (tests 110-127)

v0.19.3

Released: 2026-05-07 17:46:34 -0400

v0.19.3: fix 6 known bugs, add regression tests bug072-077

• BUG-001 (type_checker.cpp): Result in arithmetic now emits actionable error “Cannot use Result as X in arithmetic — Unwrap first with ?! or raw keyword”
• Bugs 1,2,3,4,6: confirmed already resolved prior to v0.19.3; added regression tests as canaries (bug072-075, bug077)
• Regression tests: bug072 non-pub helper from pub; bug073 ahget missing key; bug074 @func_name as call arg; bug075 loop scope after exit; bug076 Result arithmetic error message; bug077 large pick() 30 arms
• CTest 4/4 passing

v0.19.2

Released: 2026-05-07 13:04:01 -0400

v0.19.2 Phase 4: fix borrow checker to properly check loop() statement bodies

v0.19.1

Released: 2026-05-07 12:25:36 -0400

v0.19.1 Phase 3+4: struct codegen audit & struct == rejection

Phase 3 (Extern-Struct Cleanup): - Verified pass(extern_fn()) works correctly — limitation was already fixed in v0.19.0 - Added regression test bug061: struct return value used directly as function argument without temp variable (exits 12)

Phase 4 (Struct Codegen Audit): - All struct tests pass: nested_struct, generic_struct_basic, struct_impl_method, array_in_struct, struct_literal_comprehensive - Struct copy semantics correct (value-type, including array fields) - Fixed: struct == struct generated invalid LLVM IR (icmp eq on aggregate type) - Now caught in type_checker.cpp with clear error message: “Operator ‘==’ is not defined for struct type ‘Foo’. Implement an equality method on the struct instead.” - Added rejection test bug062: struct == struct correctly rejected - CTest 4/4

v0.19.0

Released: 2026-05-07 05:36:51 -0400

v0.19.0: Phase 4 — slice polish (inclusive/exclusive/variable-index slices)

v0.18.7

Released: 2026-05-06 10:50:49 -0400

v0.18.7: DO-330 TQL-4 qualification kit (TQP, TOR, TVP, TAS, DO333, EVIDENCE_INDEX)

v0.18.6

Released: 2026-05-06 09:29:32 -0400

v0.18.6: SV-COMP benchmarks — 16/16 correct, score +26

Add 16 SV-COMP benchmark programs across 4 categories:

ReachSafety (4): - safe_counter.npk : loop(0,10,1) counter, error unreachable (TRUE, runtime) - safe_linear_search.npk : array search, target found (TRUE, runtime) - unsafe_div_noguard.npk : unchecked division, Z3 finds b=0 (FALSE, z3verify) - unsafe_contract_chain.npk: two-level contract, inner proven, outer violated (FALSE, z3verify)

MemSafety (4): - safe_alloc_free.npk : malloc+free, Z3 proves no UAF (TRUE, z3verify) - safe_two_allocs.npk : two malloc+free pairs, both clean (TRUE, z3verify) - unsafe_use_after_free.npk: UAF, ARIA-022 compile rejected (FALSE, compile_reject) - unsafe_double_free.npk : double-free, ARIA-022 compile rejected (FALSE, compile_reject)

NoOverflows (4): - safe_small_arith.npk : 100+200=300, ERR not triggered (TRUE, runtime) - safe_loop_sum.npk : sum 0..9=45, ERR not triggered (TRUE, runtime) - unsafe_overflow_intmax.npk: INT_MAX+1 -> ERR -> exit 1 (FALSE, runtime) - unsafe_err_propagation.npk: ERR sticky (ERR*0=ERR) -> exit 1 (FALSE, runtime)

Termination (4): - terminates_bounded_loop.npk : loop(0,100,1), exits 0 (TRUE, runtime) - terminates_countdown.npk : countdown 10->0, exits 0 (TRUE, runtime) - terminates_linear_search.npk: fixed search both paths exit 0 (TRUE, runtime) - terminates_nested_loops.npk : nested 5x5 loops, exits 0 (TRUE, runtime)

Each benchmark has a .yml metadata file with: - expected_verdict: true|false - verdict_strategy: runtime|z3verify|compile_reject - verify_flags for Z3 compiler invocation

Runner: tests/sv-comp/run_svcomp.sh - SV-COMP official scoring (+2 TRUE correct, +1 FALSE correct, -32/-16 wrong) - Parses Z3 report from compiler output (flags are compile-time, not runtime)

CTest: svcomp_benchmarks (TIMEOUT 300, label v0.18.6)

Results: 16/16 correct, 0 incorrect, SV-COMP score +26 CTest: 2/2 pass (juliet_cwe_tests + svcomp_benchmarks)

v0.18.5

Released: 2026-05-06 03:06:46 -0400

v0.18.5: Juliet CWE test suite — 9 CWEs, 18/18 pass, CTest 1/1

Implements Aria v0.18.5: Juliet CWE Test Suite.

Covered CWEs (18 test cases across 9 categories): Runtime prevention (TBB ERR sentinel): CWE-190 Integer Overflow — tbb32 overflow → ERR → exit 1 CWE-190b ERR Propagation — ERR stickiness (ERR * 0 = ERR, not 0) CWE-191 Integer Underflow — tbb32 underflow → ERR → exit 1 CWE-369 Divide by Zero — tbb32 / 0 → ERR → no SIGFPE

Compile-time rejection: CWE-252 Unchecked Return — Result silently unwrap = compile error CWE-415 Double Free — ARIA-022 double free = compile error CWE-416 Use After Free — ARIA-022 use after free = compile error CWE-194 Sign Extension — int32 → uint32 implicit cast = compile error CWE-196 Unsigned→Signed Conv — uint64 → int32 implicit cast = compile error

Structurally impossible (documented P3 in CWE_MATRIX.md): CWE-121/122/124/125/126/787 — no raw array type in Aria

Files added: tests/juliet/run_juliet.sh — test runner (compile-reject/bad/good) tests/juliet/CWE_MATRIX.md — full CWE coverage matrix tests/juliet/cwe_190_/ — overflow + ERR propagation tests tests/juliet/cwe_191_/ — underflow tests tests/juliet/cwe_369_/ — divide-by-zero tests tests/juliet/cwe_252_/ — unchecked return compile tests tests/juliet/cwe_415_/ — double free compile tests tests/juliet/cwe_416_/ — use-after-free compile tests tests/juliet/cwe_194_/ — sign extension compile tests tests/juliet/cwe_196_/ — unsigned-to-signed compile tests tests/CMakeLists.txt — CTest entry juliet_cwe_tests

CTest: 1/1 (juliet_cwe_tests), labels: security;juliet;cwe;v0.18.5

v0.18.0

Released: 2026-05-03 22:06:12 -0400

Aria v0.18.0: K Framework executable semantics seed

v0.17.5

Released: 2026-04-07 12:29:05 -0400

v0.17.5: Final Audit — Installers, Packaging & Distribution series complete

v0.17.4

Released: 2026-04-07 12:22:04 -0400

v0.17.4: Documentation — INSTALL.md, tool guides, README updates

v0.17.3

Released: 2026-04-07 12:16:42 -0400

v0.17.3: aria-pkg remote package fetch from GitHub registry

v0.17.2

Released: 2026-04-07 12:00:48 -0400

v0.17.2: RPM package builder

packaging/build-rpm.sh creates aria-VERSION.x86_64.rpm. Tested build with rpmbuild 4.18.2.

v0.17.1

Released: 2026-04-07 11:54:32 -0400

v0.17.1: Debian .deb package builder

packaging/build-deb.sh creates aria_VERSION_amd64.deb. Tested install/uninstall/purge on Mint 22.1.

v0.17.0

Released: 2026-04-07 11:36:10 -0400

v0.17.0: Enhanced universal install script

Enhanced install.sh for cross-distro support, aria-make/libc, and ARIA_HOME environment setup.

v0.16.12

Released: 2026-04-07 11:21:35 -0400

v0.16.12: Final Audit & Series Wrap-Up - 0 TODO/FIXME/HACK in C++, CTest 4/4, 800K+ fuzz (0 crashes), v0.16.x series complete

v0.16.8

Released: 2026-04-06 23:37:23 -0400

v0.16.8: Documentation update — README, guides, version headers

README.md: - Version v0.13.7 → v0.16.7, date April 4 → April 6, 2026 - Added v0.14.x (SMT expansion), v0.15.x (self-hosting), v0.16.x (code review) to status and roadmap - Test count 959 → 1,015, stdlib 60 → 72 modules - Fixed Z3 contract example syntax (Result→int32, parenthesized→bare requires, multi-requires→comma-separated) - Replaced fictional quantum/superpose()/collapse() example with real Q3/Q9/Q21 API from stdlib/quantum.aria - Updated specialist model reference (v0.3.x→v0.16.x) - Removed stale a.out.s build artifact

docs/ guides: - GC_TUNING_GUIDE.md, MACRO_AUTHORING_GUIDE.md: version header v0.8.4→v0.16.7 - WASM_GUIDE.md: version reference updated

v0.16.7

Released: 2026-04-06 21:02:02 -0400

v0.16.7: Error & warning message improvements - 37+ messages improved across 9 files

v0.16.6

Released: 2026-04-06 20:20:52 -0400

v0.16.6 — stdlib code review (72 files)

Code review of all 72 stdlib .aria files (15,014 lines):

Self-hosted compiler modules (12 files): - module_table.aria: Fixed mt_resolve_import using seg_count as index instead of incrementing counter - module_resolver.aria: Fixed invalid $i loop var, int32/int64 type mismatch in mr_resolve_logical - visibility_checker.aria: Fixed error message using sym_name where line number was expected

Pre-5.x frontend modules (7 files): - lexer.aria: Fixed timeout 10s ./build/ariac /tmp/test_dollar_type.aria -o /tmp/test_dollar_type 2>&1 error recovery to emit TK_BANG_BANG (was 2x TK_BANG) - parser.aria: Fixed pass/fail to support both ‘pass expr;’ and ‘pass(expr);’ - type_checker.aria: Fixed flag bit mismatch with parser (FLAG_IS_PUBLIC/ FLAG_IS_CONST swapped), literal constant desync (LIT_CHAR=6 to match parser), NT_LOOP body at child[3] not child[0], NT_TILL body at child[2] not child[1], removed dead LIT_NIL/LIT_ERR/LIT_UNKNOWN branches

Core stdlib (53 files): - core.aria: Fixed undefined std.mem.alloc -> aria_libc_mem_malloc, invalid result -> result, nonexistent byte -> int32 - pool_alloc.aria: Fixed stale comment (4 -> 5 int64 header), removed dead manual counter (replaced with $)

53 core stdlib files reviewed — all others clean. Tests: 1003/1011 pass, 0 fail, 8 skip, 0 timeout

v0.16.5-5

Released: 2026-04-06 19:35:21 -0400

v0.16.5-5: AriaString ABI fix (26 functions), TokenType enum sync (269 entries), test cleanup

Compiler fixes: - AriaString ABI: all 26 extern C string-returning functions now return AriaString by value (data in RAX, length in RDX) instead of AriaString* pointer - lex_helpers.cpp: 5 functions (lex_get_lexeme, lex_get_substr, etc.) - ast_helpers.cpp: 15 functions (ps_peek_, ps_previous_, ast_get_str*, etc.) - sema_helpers.cpp: 6 functions (tc_get_error, tc_type_name, etc.) - Added lex_scan_keyword C helper to bypass AriaString ABI for keyword lookup - TokenType enum: synced all 3 .aria files to match C++ (269 entries, 0-268) - Updated stale token constants in sema_helpers.cpp (226-259 range) - Three-valued logic fixes in ir_generator.cpp - ok() function sentinel check rewrite in codegen_expr_call.cpp - Nyte raw signed format fix in ternary_ops.cpp

Test cleanup: - Deleted 3 dead sketch tests (minimal_literal, simple_literal, move_semantics_test1) - Marked 5 helper modules @skip-test (b13_mod, b1_helper_*, b1_struct_helper, b3_mod) - Marked type_mismatch_audit.aria Expected: error (intentional narrowing rejection) - Various test fixes for sub-byte types, unknown semantics, ok() wrappers

Results: 1003/1011 pass, 0 fail, 8 skip, 0 TIMEOUT, 0 SEGV (99%)

v0.16.5-4

Released: 2026-04-06 07:47:25 -0400

v0.16.5-4: Fix @cast<> on Result codegen, const folding, test fixes

Compiler fixes: - @cast<T>(pub_func()) on safety-wrapped results: the CAST handler in codegenExpression returned nullptr when source was a {T, ptr, i8} struct, leaving variables uninitialized (UB → LLVM optimizer eliminates consuming code → SEGV). Added auto-unwrap of Result structs in both the ir_generator.cpp CAST case and codegen_expr_compound.cpp codegenCast(). - Global constant folding: resolveInt()/resolveFloat() now look up IDENTIFIER operands in named_values for ConstantInt/ConstantFP initializers. - Variable init auto-unwrap of Result for direct pub-func assignments.

Test fixes: - Inverted exit codes for negative tests (debug_int1024, test_pick_each, test_unknown_pattern_type) - Cleaned up 12 test files for determinism, kitchen_sink, map, struct_param, immutable_is_error, nikola_capability, complex_generic, channel variants, complex_simple, two_level_safety

binary_test: 25/25 (was SEGV at T04 int64 round-trip) CTest: 4/4, Regression: 860/1019 pass

v0.16.5-3

Released: 2026-04-06 04:17:19 -0400

v0.16.5-3: Enforce exit restriction in lambdas + fix 52 exit-42 tests

Codegen: - Added exit-in-function check at IR generation level (codegen_expr_call.cpp) - Type checker already blocked exit in named functions, but lambda bodies bypass type checking entirely. New check uses LLVM parent function name to reject exit in any function other than main/failsafe. - Error message: ‘exit’ can only be used in ‘main’ or ‘failsafe’. Use ‘pass’/‘fail’ to return from functions and lambdas.

Tests (52 files): - Fixed exit(42)/exit(result)/pass(42)/return(42) conventions to use 0 - Tests now exit 0 on success as expected by test harness - Lambda tests (lambda_argument, lambda_variable) changed exit to pass inside lambda bodies

Regression: 763/1018 (+51 from 712/1019)

v0.16.5-2

Released: 2026-04-06 03:55:35 -0400

v0.16.5-2: Fix uint512 shift, rwlock linker, nested struct codegen

• uint512 shift: Extract first i64 limb from LBIM struct before truncating shift amount to i32. Fixes LLVM ‘Trunc only operates on integer’ error for shl/shr on uint512 operands. (+2 tests)
• rwlock: Add aria_libc_rwlock to auto-link lib_map and pthread_libs set. New shim at aria-libc/shim/stubs/aria_libc_rwlock.c wrapping pthreads pthread_rwlock_* functions. (+1 test)
• nested struct: Handle multi-level struct field assignment (o.inner.val = x) by walking MemberAccess chain to root identifier and building GEP chain through each struct level. Previously returned nullptr silently. (+1 test)
• Regression: 712/1019 (up from 708), 0 new failures.

v0.16.5-1

Released: 2026-04-06 03:26:54 -0400

v0.16.5-1: Fix drop value-sink regression + TBB sentinel severity

• drop(): Remove overly strict pointer-type requirement from v0.16.0-6. drop() now serves dual purpose: wild pointer free + value discard (sink). Managed pointer drop still correctly rejected. Recovers 89 tests.
• TBB ERR sentinel: Change addError to addWarning for direct sentinel assignment (-128 to tbb8). Assigning the sentinel value is valid code, just not idiomatic (should use ERR keyword). Recovers 3 tests.
• Regression: 708/1019 (up from 616), 0 new failures introduced.

v0.16.5

Released: 2026-04-05 20:04:18 -0400

v0.16.5: Code Review — Tools (LSP, DAP, Debugger, Doc, Pkg)

Reviewed 20 source files + 14 headers (~10,721 lines total).

Security fix: - installer.cpp: shell_escape() for safe system() calls (command injection fix)

1 file modified. Build clean, CTest 4/4, 0 regressions.

v0.16.4

Released: 2026-04-05 19:08:39 -0400

v0.16.4: Code Review — Runtime

83 .cpp files (~42,079 lines) + 50 headers (~13,264 lines) reviewed. 2 bug fixes, 3 new JIT opcodes, 1 include guard fix. 4 files modified.

Build clean, CTest 4/4, Stdlib 24/24, Regression 763/1019 (0 regressions)

v0.16.3

Released: 2026-04-05 18:48:20 -0400

v0.16.3: Code Review — Backend, Analysis & main.cpp

29 files reviewed (~49,900 lines): - Backend IR: 8 files - Backend Runtime: 6 files - Backend Headers: 11 headers - Analysis: 2 files + 2 headers - main.cpp

2 bug fixes, 6 temp debug blocks removed, ~150+ debug prints gated, 3 stale comments fixed. 10 files modified.

Build clean, CTest 4/4, Stdlib 24/24, Regression 763/1019 (0 regressions)

v0.16.2

Released: 2026-04-05 16:54:06 -0400

v0.16.2: Code Review — Semantic Analysis (18 files, 30,590 lines)

Reviewed all 18 sema source files (24,535 lines) + 17 headers (6,055 lines).

Fixes: - exhaustiveness.cpp: Added INT64_MAX overflow guard in getMissingRanges() (covered.max + 1 would wrap to negative when max == INT64_MAX) - type_checker_stmts.cpp: Removed dead resultUnwrapping variable (always false, never set), removed unused opaqueType variable, silenced unused stmt parameter in importWildcardSymbols()

Clean files (no changes needed): type.cpp, symbol_table.cpp, type_checker.cpp, type_checker_call.cpp, type_checker_expr.cpp, borrow_checker.cpp, const_evaluator.cpp, generic_resolver.cpp, safety_checker.cpp, definite_assignment.cpp, async_analyzer.cpp, closure_analyzer.cpp, visibility_checker.cpp, module_table.cpp, module_resolver.cpp, module_loader.cpp, all 17 sema headers, type_v2.h

2 files changed, +9/-6

v0.16.1

Released: 2026-04-05 16:09:09 -0400

v0.16.1: Code Review — Frontend (lexer, parser, preprocessor, AST)

Reviewed 13,266 lines across 14 frontend files (6 source + 8 headers).

Fixes: - token.cpp: Added 34 missing cases to tokenTypeToString() switch (MOVE, EXIT, RAW, DROP, OK, DEFAULTS, stack ops, hash ops, RULES, LIMIT, AS, REQUIRES, ENSURES, INVARIANT, FIX256, TFP32, TFP64) - ast_node.cpp: Added 11 missing cases to nodeTypeToString() (DEFAULTS, VECTOR_CONSTRUCTOR, RULES_DECL, OPAQUE_STRUCT, TRAIT_DECL, IMPL_DECL, PROVE, ASSERT_STATIC, FALL, SAFE_REF_TYPE, OPTIONAL_TYPE) - parser.cpp: Fixed parseBlock() nesting depth not decremented on overflow - preprocessor.cpp: Removed unused current_macro_args variable - warnings.cpp: Updated stale comment (analysis passes are implemented) - lexer.cpp: Fixed misleading ‘recursively’ comment to ‘iteratively’

Clean files (no changes needed): - lexer.cpp, lexer.h, parser.h, preprocessor.h, diagnostics.cpp, diagnostics.h, warnings.h, expr.cpp, stmt.cpp, type.cpp, all AST headers

6 files changed, +48/-3

v0.16.0-9

Released: 2026-04-05 15:25:59 -0400

v0.16.0-9: Failing Tests + Final Regression

• Added negative test support to stdlib/run_all_tests.sh and integration/runner.sh Detects ‘// Expected: COMPILER ERROR’ header, inverts pass/fail logic
• All 15 target tests pass (correctly rejected by compiler)
• Removed 4 stale negative markers from stdlib tests that now compile correctly
• Replaced hardcoded test list with glob pattern in run_all_tests.sh
• Stdlib: 24/24, CTest: 4/4, Full regression: 827/1019 (81%)
• TODO/FIXME: 0 markers remaining in src/ + include/
• All 9 v0.16.0-x patches now RELEASED

v0.16.0-8

Released: 2026-04-05 14:21:49 -0400

v0.16.0-8: Parser + Tools + Misc TODOs

• parser.cpp: GPU kernel dual detection — #[gpu_kernel] attribute is primary path, gpu_ prefix kept as backward-compatible fallback with priority guard
• stmt.h + parser.cpp + type_checker_stmts.cpp: pub struct support — added isPublic field to StructDeclStmt, parsing ‘pub struct:’, visibility-aware module export
• literal_converter.cpp: Split flt256/512 float semantics — flt256 uses PPCDoubleDouble (106-bit mantissa), flt512 stays IEEEquad until MPFR integration
• dap_server: Variable children expansion — track expandable types via reference map (structs/arrays/pointers), recursive child enumeration, clear on step/continue
• aria_formatters: GC pointer synthetic provider ported to Python (LLDB 20+) — embedded script exposes dereferenced value and object header metadata fields (color, pinned, forwarded, is_nursery, size_class, type_id)
• LSP server: Semantic analysis integration — TypeChecker runs after parsing, reports type errors and warnings as diagnostics; added SEMA_SOURCES + LLVM linkage to aria-ls CMake target

7 items resolved (6 original + 1 deferred from v0.16.0-6) 10 files changed, 285 insertions, 67 deletions

v0.16.0-7

Released: 2026-04-05 13:58:37 -0400

v0.16.0-7: Sema — 14 analysis pass TODOs resolved

safety_checker.cpp (5): - Parse SAFETY comments from source (// SAFETY: acknowledgments) - Check func->isAsync for async concurrency warnings - Check var->isWild/isWildx storage qualifiers (not string matching) - Detect @ address-of and <- dereference via UnaryExpr token types - Use sourceFile parameter for diagnostic file paths

generic_resolver.cpp (2): - Resolve struct type aliases via StructType::getName() canonicalization - Document recursive analysis delegation to TypeChecker (already wired)

module_table.cpp (2): - Implement relative import resolution via std::filesystem - Implement package-level access using top-level module path

borrow_checker.cpp (1): - Enhanced proveIndexDisjoint: literal fast-path + binary offset detection (i+K vs i), Z3 range path documented for Rules constraint wiring

const_evaluator.cpp (1): - Look up struct fields from SymbolTable for compile-time type info

type.cpp (1 — deferred from v0.16.0-6): - FunctionType::isAssignableTo() with parameter contravariance and return type covariance

visibility_checker.cpp (1): - Package detection via top-level module path + filesystem directory

Also verified: module_loader.cpp has 0 remaining TODOs (v0.16.0-3 fix). 8 files changed, 346 insertions, 75 deletions.

v0.16.0-6

Released: 2026-04-05 13:25:01 -0400

v0.16.0-6: Sema — 21 type checker TODOs resolved

NEW: Safe implicit integer widening in isAssignableTo() - int8→int16→int32→int64 (signed family) - uint8→uint16→uint32→uint64 (unsigned family) - TBB widening still forbidden (sentinel semantics) - Cross-family/narrowing still rejected

type_checker_call.cpp (3 items): - Module call arguments now type-checked (isAssignableTo + canCoerce) - Normal call path includes canCoerce fallback for widening - drop() verifies wild pointer requirement

type_checker_stmts.cpp (10 items): - Array size: constant folding via ConstEvaluator - SIMD lane count: power-of-2 validation - Specialized struct: monomorphizer already registers, internal error fallback - TBB assignment: compile-time range checking via ConstEvaluator - Contracts: reject function calls (side-effect check) - Trait methods: validate parameter/return types exist - Impl: resolve primitive types, verify method signature match - Fail: accept TBB error codes alongside standard integers - Module struct export: documented (pub modifier needs parser support)

type_checker.cpp (4 items): - Await/Future: documented async model (Future unwrap ready) - Template literals: validate interpolated types are primitive - Unknown propagation: returns UnknownType (not int32) - Unwrap operator (?): checks Result, returns inner T

type_checker_expr.cpp (3 items): - .error access: documented int32 convention - Safe navigation: documented optional gap - Member access: handles dyn Trait + obj types

type_checker.h (1 item): - toString doc: updated to reflect primitive-only rule

6 files changed, 206 insertions, 65 deletions Build clean, CTest 4/4

v0.16.0-5

Released: 2026-04-05 12:26:45 -0400

v0.16.0-5: Resolve 21 backend codegen TODOs

v0.16.0-4

Released: 2026-04-05 11:51:56 -0400

v0.16.0-4: Async/Runtime stub implementations — 16 TODOs resolved

Code cache serialization: - aria_code_cache_save/load: binary format (ARCC magic, versioned, per-entry hash/size/backend/opt_level/code)

GC-coroutine integration: - init_gc: aria_gc_init + self-reference gc_handle - shutdown_gc: unregister JIT roots, clear gc_handle - IncrementalCoroGC: configurable frames_per_cycle scanning + SATB write barriers - GenerationalCoroGC: young/old generation tracking, collect_young/collect_full

Async stream operations: - MapStream::next: poll source, apply mapper, return mapped StreamItem - FilterStream::next: loop until predicate match or end-of-stream - collect_stream: drain to vector via polling - for_each_stream: iterate with callback - fold_stream: reduce with accumulator

Async networking: - HTTP response reading: 4KB chunked reads, Content-Length awareness, full HTTP status/header/body parsing

NUMA work stealing: - NumaExecutor: topology detection via /sys/devices/system/node/online - set_cpu_affinity: pthread_setaffinity_np via native_handle - wait_all: upgraded sleep-poll to condition_variable wait_for

Build: 0 new warnings, CTest 4/4, smoke test OK

v0.16.0-3

Released: 2026-04-05 11:31:56 -0400

v0.16.0-3: BUG-08 + Memory/Ownership Fixes

v0.16.0-2

Released: 2026-04-05 11:15:58 -0400

v0.16.0-2: Fix 4 Wrong-Value & Behavior Bugs (B6, B7, B9, B11)

v0.16.0-1

Released: 2026-04-05 11:15:25 -0400

v0.16.0-1: Bug Verification — Regression Tests for B1-B5

v0.16.0

Released: 2026-04-05 09:18:43 -0400

v0.16.0: Dead Code Removal & Initial Cleanup

• Removed ~46K lines of dead code (.bak directories)
• Removed 120+ stale backup/temp files
• Guarded all raw debug prints behind ARIA_DEBUG_CODEGEN
• Updated .gitignore for backup/temp patterns
• Build: clean (0 warnings), CTest 4/4

v0.15.3

Released: 2026-04-05 08:40:57 -0400

v0.15.3: Final Audit & Self-Hosting Census — v0.15.x series complete

v0.15.2

Released: 2026-04-05 08:01:51 -0400

v0.15.2: Tier 3 Tool Ports — Doc Generator, Package Manager, Project Config (36 new tests, 144 total)

v0.15.1

Released: 2026-04-05 06:42:03 -0400

v0.15.1: Tier 2 self-hosting — Closure Analyzer, Warnings, Module Resolver, Usage Stats

v0.15.0

Released: 2026-04-05 05:53:47 -0400

v0.15.0: Self-hosting foundation — 5 compiler modules ported to Aria

Ports: Visibility Checker, Async Analyzer, Diagnostics Engine, Module Table, Definite Assignment Analysis

60/60 tests passing, no regressions, 3070 lines added

v0.14.5

Released: 2026-04-05 04:13:41 -0400

v0.14.5: SMT Documentation, Best Practices & Final Audit — final v0.14.x

v0.13.7

Released: 2026-04-04 18:01:15 -0400

v0.13.7: Final Audit, Cleanup & Release

AUDIT-01: 959 tests — 827 pass, 132 expected-fail, 0 genuine failures AUDIT-02: Fuzzer 17h+, 4600+ tests, 0 crashes, 0 timeouts AUDIT-03: Compile benchmarks ~170ms/file average AUDIT-04: KNOWN_ISSUES.md updated to v0.13.7 (was v0.7.4) AUDIT-05: BUGS file cleaned — resolved items moved to resolved section AUDIT-06: MASTER_ROADMAP.md — v0.11.x, v0.12.x, v0.13.x marked Released AUDIT-07: 102 packages (17 pure, 17 libc, 68 FFI), 60 stdlib modules

v0.13.6

Released: 2026-04-04 17:27:10 -0400

v0.13.6: Fix @ function pointer syntax with trampoline generation

• @func_name now correctly creates function pointers from named functions
• Generates trampoline wrapper to bridge calling conventions (env_ptr ignored)
• Fat pointer stored as {trampoline_ptr, null} for consistent indirect calls
• Keyword/builtin/operator audit: 95/100, no blocking gaps
• ? unwrap + comparison confirmed working (was stale binary artifact)
• 0 regressions (958 tests, 826 pass, 132 pre-existing failures)

v0.13.5

Released: 2026-04-04 13:47:06 -0400

v0.13.5: Deferred Language Features - Variadic/Rest/Spread + ahash Ops

v0.13.0

Released: 2026-04-04 01:01:21 -0400

v0.13.0 — Critical codegen fixes

Fixed: - BUG-06: _test filename segfault (imported module main collision) - BUG-09: Computed fixed constants zeroed on module import

Verified already fixed: BUG-01-05, BUG-07-08, BUG-10, BUG-13 Resolved: BUG-11 (proper error). Mitigated: BUG-12 (deferred to v0.13.2). No regressions.

v0.11.0

Released: 2026-04-03 10:33:34 -0400

v0.11.0: Concurrency stdlib ported to aria-libc

8 modules ported: thread, mutex, condvar, rwlock, channel, actor, thread_pool, shm Compiler fix: bool type in extern block mapFFIType 39 concurrency tests passing, all regression tests clean Direct extern stdlib files: 28 → 20

v0.10.3

Released: 2026-04-03 05:00:43 -0400

v0.10.3 — Expand stdlib test suites to 12 tests each, gitignore cleanup

• test_arena.aria: expanded to 12 tests (create, alloc, reset, used, remaining, write/read, destroy, overflow, multi-reset, zero-cap, large-alloc, interleaved)
• test_binary.aria: expanded to 12 tests (new, write/read int32/int64/flt64, seek, free, overwrite, multi-type, roundtrip, large)
• test_net.aria: expanded to 12 tests (connect, send, recv, close, listen, resolve, nonblocking, double-close, send-closed, large-send, multi-connect, server-close)
• test_pipe.aria: expanded to 12 tests (create, write_fd, write/read int64, close_write, close_read, multi-write, large-value, sequential, destroy, create-destroy, stress)
• test_pool.aria: expanded to 12 tests (create, get, put, available, write/read, destroy, exhaust, reuse, multi-pool, boundary, stress)
• test_process.aria: expanded to 12 tests (getpid, getppid, system, getenv, pid-nonzero, ppid-nonzero, system-fail, env-missing, pid-stable, system-echo, env-path, pid-consistency)
• test_signal.aria: expanded to 12 tests (register, pending, ignore, restore, multi-register, pending-initial, ignore-restore, register-restore, double-register, pending-after-ignore, restore-unregistered, register-chain)
• .gitignore: added compiled test binaries in tests/ to ignore list

v0.10.0

Released: 2026-06-14 11:04:52 -0400

v0.10.0 — NIKOS TUI interactive terminal dashboard

npkc –tui launches an htop-style analysis dashboard: - Live background analysis via npkc –analyze subprocess - Braille spinner + PostEvent handoff to UI thread - SummaryBar, FilterBar (text/status/sort), CheckTable, DetailPanel - Overlays: timing chart, cross-val, promo, export, help - ftxui v6.1.9 via CMake FetchContent (NITPICK_HAS_TUI=ON default)

NTU-001–039 complete.

v0.9.4

Released: 2026-04-02 21:53:32 -0400

v0.9.3 — Mark 38 stdlib modules with deprecation notices

Modules using direct extern FFI are now marked as deprecated. Future versions will migrate these to aria-libc shims. Already migrated: math, io, string, mem (v0.9.1) Pure Aria (no migration needed): fmt

v0.9.3

Released: 2026-04-02 21:53:32 -0400

v0.9.3 — Mark 38 stdlib modules with deprecation notices

Modules using direct extern FFI are now marked as deprecated. Future versions will migrate these to aria-libc shims. Already migrated: math, io, string, mem (v0.9.1) Pure Aria (no migration needed): fmt

v0.9.1

Released: 2026-04-02 19:11:03 -0400

v0.9.1: Core stdlib ports — math, io, mem, string to aria-libc; new fmt.aria

Ported 4 stdlib modules from direct extern func to aria-libc shims: - math.aria: 7 externs -> 0 (extern “aria_libc_math” block) - io.aria: 8 externs -> 0 (extern “aria_libc_io” block) - mem.aria: 7 externs -> 0 (extern “aria_libc_mem” block) - string.aria: 18 externs -> 0 (builtins + aria_libc_string + aria_libc_mem)

New: stdlib/fmt.aria — pure Aria string formatting (0 externs) fmt/fmt2/fmt3/fmt4 with {} placeholders, fmt_int, fmt_float, fmt_bool, fmt_hex, fmt_pad_left, fmt_pad_right, fmt_repeat

Total: 40 inline extern func declarations eliminated from stdlib. All 5 modules tested: 65 assertions passing.

v0.9.0

Released: 2026-06-14 10:45:26 -0400

v0.9.0: NIKOS LSP integration — inline diagnostics in editors via npk-ls (NLS-001–037)

v0.8.4

Released: 2026-04-02 17:08:58 -0400

v0.8.4: Polish & Release — GC+JIT root tracking, Ord derive, compile benchmarks, docs

GC improvements: - Wire coroutine root scanning (scan_frames) into minor_gc + major_gc (3 call sites) - Add JIT root tracking API: aria_gc_register_jit_root / aria_gc_unregister_jit_root - Wire JIT root scanning into all GC mark phases - Resolve TODO in gc_integration.cpp suspend_frame()

Derive macro system (fixes v0.8.3 IR codegen gap): - Auto-register built-in derive traits (ToString, Eq, Hash, Clone, Debug, Ord) - Add Ord derive: lexicographic field-by-field less_than comparison - Inject synthetic derive impls into AST before function declarations - Add getSyntheticNodes() accessor on TypeChecker - All derives now fully functional end-to-end (type check → IR → execution)

Compiler benchmarks: - Add bench_compile_time.sh for compilation speed tracking

Documentation: - GC_TUNING_GUIDE.md: GC architecture, safepoints, coroutine/JIT integration, tuning - MACRO_AUTHORING_GUIDE.md: Derive traits, attribute macros, usage examples

v0.8.3

Released: 2026-04-02 16:20:09 -0400

v0.8.3: Macro System Expansion — AST macros, derive, comptime, attributes

• AST-level macros: macro:name = (params) { body }; with name!(args) invocation
• Derive macros: #[derive(ToString, Eq, Hash, Clone, Debug)] on structs
• Attribute macros: #[inline], #[noinline], #[align(N)], #[gpu_kernel], #[gpu_device]
• Comptime: verified comptime(expr) and comptime { block } still work
• Macro expansion via AST cloning with parameter substitution
• Type checker: macro registry, derive expansion generating synthetic impls
• IR generator: codegen for expanded macro bodies (blocks and expressions)
• New tokens: TOKEN_KW_MACRO, TOKEN_KW_DERIVE
• New AST nodes: MacroDeclStmt, MacroInvocationExpr, Attribute struct
• Tests: test_macro_basic.aria, test_attribute_macros.aria, test_comptime_basic.aria
• All existing tests pass (4/4 ctest)

v0.8.0

Released: 2026-06-14 10:32:57 -0400

v0.8.0: NIKOS UI layer — HTML/JSON report output + –analyze mode

New: NikosHtmlReport, –nikos-report, –analyze, –nikos-domain, –nikos-checkers, –nikos-entry, –nikos-threads, –nikos-widening-delay NUI-001–038 complete.

v0.7.4.1

Released: 2026-04-02 09:27:21 -0400

v0.7.4.1: 836/836 tests passing (100%) — bug fix release

Compiler fixes: - LLVM verify errors: 117 codegen type mismatches eliminated - Move checker (ARIA-019): extern wild params as COPY not MOVE - Realloc (ARIA-014): old pointer marked MOVED after realloc - branchAlwaysReturns: exit calls recognized as terminators - nit_* builtin override: user-defined functions take precedence - ERR/unknown sentinel: keyword vs string literal disambiguation - Compound assignment RHS type coercion - String_concat Result unwrap

Fuzzer: No crashes on extended run

v0.7.4

Released: 2026-04-02 00:43:32 -0400

Merge branch ‘dev’

v0.7.3

Released: 2026-04-01 20:52:14 -0400

v0.7.3: Register Allocator — Linear scan allocation, liveness analysis, spill/reload, virtual register API

Core Features: - Linear scan register allocation with O(N) complexity - Lazy IR buffering: zero overhead when only physical registers used - Per-opcode liveness analysis for all 55+ IR opcodes - Dual scratch register design (R10/R11, XMM14/XMM15) - RBP-relative spill/reload with automatic stack slot management

Virtual Register API: - aria_asm_vreg_new_gpr() / aria_asm_vreg_new_xmm() - GPR IDs: 256-511, XMM IDs: 512-767 - aria_asm_vreg_count() / aria_asm_spill_count() for introspection - FFI bindings in jit.aria

Auto-Frame Management: - Detects when spills or callee-saved registers need preservation - Auto-injects frame setup/teardown + CSR push/pop when no user prologue - SysV AMD64 ABI compliant callee-saved register preservation - Caller-saved registers allocated first to minimize overhead

Physical Register Reservation: - Detects physical registers used directly in IR during liveness analysis - Reserves them from virtual register allocation to prevent conflicts - Mixed physical + virtual register usage fully supported

Register Landscape: - 12 allocatable GPRs (RAX,RCX,RDX,RSI,RDI,R8,R9,RBX,R12-R15) - 14 allocatable XMMs (XMM0-XMM13) - R10/R11, XMM14/XMM15 reserved as scratch pairs - RSP/RBP reserved

Tests: 17 tests (21 assertions) — all pass at -O2 Regression: v0.7.2 (23/23), v0.7.1 security (10/10) — all pass assembler.cpp: ~1100 → ~1850 LOC

v0.7.2

Released: 2026-04-01 19:47:31 -0400

v0.7.2: JIT Instruction Set Expansion

• Memory operations: MOV load/store [base+offset], LEA with full ModR/M + SIB encoding
• SSE2 floating-point: MOVSD, ADDSD, SUBSD, MULSD, DIVSD, UCOMISD (XMM0-XMM15)
• SIMD packed float: MOVAPS (aligned load/store), ADDPS, MULPS (4x float32)
• CALL: direct (rel32), indirect (register), absolute (MOV+CALL via R11)
• Stack frame: store_local/load_local RBP-relative convenience wrappers
• Extended integer: ADD/SUB imm32, XOR/AND/OR/NOT/NEG, SHL/SHR/SAR imm8, CMP imm32
• Extended jumps: JL, JLE, JG, JGE, JB, JBE, JA, JAE via shared emit_jcc_rel32
• Float execution: aria_asm_execute_f64, aria_asm_execute_f64_f64
• Updated jit.aria FFI bindings + XMM register constants + ABI FP constants
• 23 tests (test_jit_v072.cpp): all pass
• Instruction count: 12 → 45+ x86-64 instructions

v0.7.1

Released: 2026-04-01 19:24:38 -0400

v0.7.1: WildX Security Hardening

• ASLR for JIT pages via getrandom() hint addresses
• Guard pages (PROT_NONE sentinels) around executable regions
• FNV-1a code signing: hash computed at seal, verified at every execute
• WildX quota enforcement (64MB default, atomic CAS)
• Audit logging (–wildx-audit): ALLOC/SEAL/EXEC/FREE/TAMPER events
• CLI flags: –wildx-audit, –wildx-guard-pages with IR injection
• Hash verification added to all assembler execute paths
• 10 security tests (test_wildx_security.cpp)
• Updated .gitignore to track tests/**/test_*.cpp

v0.7.0

Released: 2026-06-14 09:46:35 -0400

v0.7.0: NIKOS frontend enhancement series

Completes the NIKOS/IKOS abstract interpretation integration in Nitpick.

Highlights: - Fixed 3 silent bugs: checkKindToFlag nullptr for dca/dfa/fca - NikosDomain enum: 9 abstract domains selectable (gauge, var-pack-dbm, etc.) - NikosAnalysisOptions: full fixpoint engine control (widening delay/period/strategy, narrowing, procedurality, pre-passes) - NikosDatabaseReader: reads IKOS SQLite DB for call stacks, timing, operands - NikosCheckResult.function_name and call_chain now populated - Cross-validation enhanced with interprocedural call chain matching - Timing data exposed in NikosAnalysisResult.timing and to_text()/to_json() - Hardware address and memory watch support for embedded targets - Multiple entry points fully passed (not just first)

NKS tracker: 31 items completed across 5 subreleases (0.7.0–0.7.5)

v0.6.4

Released: 2026-04-01 17:20:19 -0400

v0.6.4: Borrow Checker Polish & Diagnostics

• Fix Result type i1/i8 LLVM verifier mismatch bug
  • codegen_expr.cpp: closure Result structs use i8 instead of i1
  • ir_generator.cpp: impl method and lambda Result structs use i8
  • borrow_traits.aria now compiles successfully
• Structured diagnostic codes (ARIA-XXX) for all borrow errors
  • ARIA-014: Leak detection / defer enforcement
  • ARIA-016: Pin violations
  • ARIA-017: Reference escape
  • ARIA-019: Move conflicts / use-after-move
  • ARIA-020: Call-site aliasing / reborrow
  • ARIA-022: Wild pointer (use-after-free, double-free, etc.)
  • ARIA-023: Borrow conflicts (mutable/immutable)
  • ARIA-024: Trait method validation
  • ARIA-025: Loop-carried borrow conflicts
  • ARIA-026: Assignment to borrowed variables
  • 55 error sites tagged with diagnostic codes
  • tagCode() infrastructure for BorrowError
• –borrow-dump flag for borrow state visualization
  • Per-function dump of active loans, pins, wild state, moves
  • Shows loan origins, variable depths, allocation sizes
  • Outputs to stderr for easy filtering
• All 9 borrow tests + 18 adversarial tests pass
• Compilation times under 200ms for all test files

v0.6.3

Released: 2026-04-01 14:17:23 -0400

Merge branch ‘dev’

v0.6.2

Released: 2026-04-01 13:13:22 -0400

Merge branch ‘dev’

v0.6.1

Released: 2026-04-01 12:44:55 -0400

v0.6.1: Precision Improvements

v0.6.0

Released: 2026-04-01 12:09:03 -0400

v0.6.0: Inter-Procedural Borrow Analysis

v0.5.5

Released: 2026-04-01 11:14:17 -0400

v0.5.5 — Benchmark Suite, Configurable Timeouts, Verification Guide

v0.5.4

Released: 2026-04-01 09:53:36 -0400

v0.5.4: Advanced Concurrency & Memory Verification

Phase 2d — Concurrency verification (–verify-concurrency): - Data race detection: tracks shared variable accesses across spawner and thread functions, detects unprotected write-write and read-write races via Z3, recognizes mutex lock/unlock regions - Deadlock freedom: builds lock acquisition graph, encodes consistent ordering via Z3 integer ordinals (SAT=safe, UNSAT=cyclic deadlock)

Phase 2e — Memory safety verification (–verify-memory): - Use-after-free proofs: collects free/use events with branch guard conditions, uses Z3 to check if freed-before-use path is reachable - Recursion bounding: proves recursive functions terminate by checking limit<> constrained variables strictly decrease at each self-call; computes max depth via Z3_optimize

New test files: - test_z3_data_race.aria (2 disproven, 1 proven) - test_z3_deadlock.aria (1 disproven) - test_z3_use_after_free.aria (2 disproven, 2 proven) - test_z3_recursion_bounded.aria (4 proven, depths ≤ 100 and ≤ 20)

All existing Z3 verification tests pass without regression.

v0.5.3

Released: 2026-04-01 08:00:17 -0400

v0.5.3: Refinement Types + Rules Integration

Phase 12: Rules transitivity proofs (verifyRulesNarrowing) - Verifies at call sites that caller’s Rules constraint subsumes callee’s - Scans callee body for limit<> VarDecls to discover parameter Rules - PROVEN when narrowing is valid, DISPROVEN with error when not

Phase 13: Pattern exhaustiveness via SMT (provePickExhaustiveness) - Uses Z3 to verify pick() cases cover entire Rules-constrained domain - Encodes patterns as Z3 disjuncts (literal, range, comparison, wildcard) - Provides counterexample value when non-exhaustive - Type checker defers to SMT for limit<> selectors instead of requiring (*)

Phase 14: Rules + null interaction (proveRulesExcludesNull) - Proves whether Rules constraints exclude NIL (0) - Automatically checked when limit<> variables are declared - PROVEN = variable is never null, DISPROVEN = could be null

Phase 15: Return bounds inference (inferReturnBounds) - Uses Z3 optimizer (minimize/maximize) to compute return value bounds - Resolves through local variable chains (pass result -> result = expr) - Scans function body for limit<> VarDecls referencing parameters - Reports inferred [min, max] range for functions with Rules-constrained params

6 new test files, 1296 insertions across 11 files.

v0.5.0

Released: 2026-04-01 04:15:12 -0400

v0.5.0: SMT Solver Deep Dive — compiler-internal optimizations

Complete v0.5.0 milestone: 10 SMT-guided compiler optimizations

New in this release (Phases 4.25–5.75): - Dead branch elimination (Z3 proves conditions always-true/false) - Bounds check elimination (Z3 proves indices always in range) - Overflow check elimination (Z3 proves no overflow under Rules constraints) - Null check elimination (Z3 + dataflow proves non-null) - Loop invariant hoisting (dataflow detects loop-invariant expressions) - Rules propagation (inter-procedural Z3 subsumption proofs) - Defaults/?| fallback elimination (proves sub-expressions infallible)

Carried from v0.4.x: - User stack fast path (tag-homogeneity proof) - User hash fast path (same for ahash) - Result elision (static infallibility analysis)

All optimizations enabled with –smt-opt flag. 7 new test files in tests/smt/ with positive and negative cases.

v0.4.7

Released: 2026-03-31 14:45:20 -0400

v0.4.7: Compiler improvements, uhash runtime, doc overhaul

v0.4.4

Released: 2026-03-31 02:16:33 -0400

v0.4.4: defaults/?| scoped fallback operator, implicit Result propagation with warnings

Features: - defaults/?| operator: scoped fallback for Result expressions - succeed(5i32) ?| 99i32 returns 5 (success path) - fail_always() ?| 99i32 returns 99 (error path) - RHS restricted to literals, variables, constants (no function calls) - Both ?| shorthand and ‘defaults’ keyword supported - Implicit Result propagation in argument position - Result auto-unwraps when passed to T parameter - On error: early return propagates error to caller - Compiler warning emitted for visibility - Warning infrastructure: type checker addWarning + getWarnings - Version bump to 0.4.4

Also includes: - Runtime memory primitives, math fmod/to_int, string conversions - Syntax migration script - Benchmark suite for user stack - SMT-guided user stack optimization - Z3 verifier enhancements

v0.4.3

Released: 2026-03-29 23:30:34 -0400

v0.4.3: Per-scope implicit user stack redesign

v0.4.2

Released: 2026-03-29 22:08:05 -0400

v0.4.2: User Stack — astack/apush/apop/apeek builtins

v0.4.1

Released: 2026-03-29 21:38:59 -0400

v0.4.1: Typed sys() returns — GETCWD and READLINK return Result

v0.4.0

Released: 2026-03-29 20:09:24 -0400

v0.4.0: sys() tiered syscalls, ?/! ergonomic operators, bug fixes

• sys.aria stdlib: 55+ safe-tier wrappers
• _? prefix shorthand for drop() (pure parser desugaring)
• _! prefix shorthand for raw() (pure parser desugaring)
• BUG-005 through BUG-011 fixes (main mandatory, fail() endpoints, type coercion)
• Fuzzer generators for syscall + drop/raw shorthand

v0.3.4-1

Released: 2026-03-29 12:36:27 -0400

README: fix code examples, update In Progress → Stable, add all 102 packages

• Move Six-stream I/O, Traits, Optional types, Channels to Stable (all implemented: runtime streams, dyn Trait vtables, T?/??/?. operators, channels + actors in stdlib)
• In Progress now: AriaX Linux, Specialist model V7
• Add 22 missing packages to table (actor, aifs, bigdecimal, channel, diff, dns, ftp, hex, ini, libc, matrix, mock, msgpack, pqueue, qt6, ringbuf, rules-common, sdl3, smtp, stats, webkit-gtk, wxwidgets)
• Fix Hello World: pass(0i32) → exit(0), failsafe signature corrected
• Fix Layer 1 failsafe: NIL(int32:err_code) → int32(tbb32:err)
• Fix Layer 2 divide: Result → int32 (implicit Result wrapping)
• Update aria-pkg table entry: 80 → 102 packages

v0.3.4

Released: 2026-03-29 11:04:26 -0400

v0.3.4: Z3 SMT Phase 2 (contracts) + Phase 3 (overflow verification)

v0.3.3

Released: 2026-03-29 09:50:29 -0400

v0.3.3: Safety showcase, tooling polish & cleanup

• Tooling verified: LSP (6 capabilities), MCP (5 tools), DAP debugger, VS Code grammar
• CI pipelines on 3 repos, badges on 6 repos
• 118 debug prints gated behind ARIA_DEBUG_CODEGEN compile flag
• 860 lines dead code removed (stale backup + #if 0 block)
• 695+ documentation corrections in aria-docs
• Getting Started guide (751 lines) + issue templates
• Fuzzer running with zero errors
• Deferred to 0.4: apm networking, distribution, AriaX, library ecosystem polish

v0.3.2

Released: 2026-03-29 08:26:39 -0400

v0.3.2: 101 packages milestone — aria-stats, aria-matrix, aria-mock, aria-bigdecimal + SDL3/wxWidgets/WebKitGTK wrapper updates

v0.3.1

Released: 2026-03-29 04:16:08 -0400

v0.3.1 — Batch 2: Networking + Serialization + Text (aria-dns, aria-smtp, aria-ftp, aria-msgpack, aria-diff)

v0.3.0

Released: 2026-03-29 03:44:11 -0400

v0.3.0: 5 new packages (rules-common, ini, hex, ringbuf, pqueue), 92 total

v0.2.45

Released: 2026-03-28 11:46:51 -0400

v0.2.45: Z3 SMT solver integration for static contract verification

• Z3Verifier class: translates Rules conditions to Z3 expressions for formal proofs
• Bitvector sorts for exact integer width matching (BV8/BV16/BV32/BV64)
• Real sort for float constraint verification
• Rules consistency checking detects contradictory constraints
• Cascading rules verification follows limit chains
• –verify flag enables Z3 pass (Phase 3.25, between type check and borrow check)
• –verify-report flag prints detailed proof summary
• Compilation aborted on provably violated constraints
• Conditional Z3 build: ARIA_HAS_Z3 compile definition when libz3 found
• 4 test files: basic proofs, complex arithmetic, violation detection, inconsistency
• Version bump 0.2.44 -> 0.2.45

v0.2.44

Released: 2026-03-28 11:13:23 -0400

v0.2.44 — Rules Array Indexing, Multi-Type Params & Null/NIL Checks

v0.2.43

Released: 2026-03-28 04:58:45 -0400

v0.2.43: Rules $.field member access & string rules

v0.2.42

Released: 2026-03-28 03:18:32 -0400

v0.2.42: Rules type parameterization

v0.2.41

Released: 2026-03-28 01:41:04 -0400

v0.2.41: Rules + limit — refinement types

v0.2.40

Released: 2026-03-28 00:35:52 -0400

v0.2.40: Reference update — docs for enums, channels, actors, traits, borrows, Type:

• README.md: Updated version history v0.2.30-v0.2.39, current status
• Version bump to 0.2.40

v0.2.39

Released: 2026-03-28 00:24:40 -0400

v0.2.39: Enums — full type system, auto-numbering, exhaustiveness

• EnumType class with proper type identity (not just int64 constants)
• Auto-numbering: omit = value, variants numbered from 0 or last+1
• Explicit and mixed auto/explicit values supported
• Enum-typed variables: Color:my_color = Color.RED
• Enum comparison with == and !=
• Parser pre-pass collects enum names for correct member access
• Exhaustiveness: getDomain supports enum types, analyzePattern handles MEMBER_ACCESS
• IR generator: mapType, mapTypeFromName, mapDebugType for enums
• 14 passing tests in tests/test_enums.aria

v0.2.38

Released: 2026-03-27 23:57:11 -0400

v0.2.38: AI-native filesystem improvements

New capabilities in aifs_shim.c: - Model format detection: GGUF, HDF5, NumPy, PyTorch, SafeTensors, ONNX, TFLite, TensorRT (magic bytes + extension fallback) - SHA-256 checksums: compute, store (xattr), verify integrity - Sequential read optimization: posix_fadvise(SEQUENTIAL), readahead() - Chunked streaming reader with get_read_buffer() - File seek support - Directory scanning: scan_models() returns tab-separated index - Custom metadata: arbitrary key-value pairs via user.aria.* xattrs

Stdlib (aifs.aria): - Extended Type:AIFs with detect_format, set/get_format, compute/get/verify checksum, open_sequential, read_chunk, get_read_buffer, seek, readahead, scan_models, set/get_meta

Package (aria-aifs): - ModelOps: batch annotate, batch checksum, batch verify directories - StreamReader: sequential file reading with kernel hints - count_annotated: count files with AI metadata

Tests: 23/23 passing - Tensor metadata (dtype, shape, checkpoint) - Format detection, set/get format - Checksum compute, verify match, verify mismatch after corruption - Sequential read, chunk read, read buffer - Custom metadata, directory scan, seek - Error cases (nonexistent file, unannotated file)

v0.2.37

Released: 2026-03-27 22:56:42 -0400

v0.2.37: Async channels & actors

Channel variants: - Buffered (bounded ring buffer, existing + enhanced) - Unbuffered (rendezvous — sender blocks until receiver takes) - Oneshot (capacity 1, auto-closes after first send) - Select mechanism: select2/3/4 with timeout (poll-based) - get_mode(), capacity(), try_send/try_recv for all variants

Actor system: - Actor spawn with behavior function (lambda-based handlers) - Mailbox-backed message passing (MPMC channel per actor) - Actor lifecycle: spawn/send/try_send/stop/destroy - is_alive/pending/mailbox introspection - Global reply channel for actor->caller communication

Stdlib: - stdlib/channel.aria: Extended with create_unbuffered, create_oneshot, get_mode, get_capacity, select2/3/4 - stdlib/actor.aria: New Type:Actor wrapper

Tests: 42 total (22 channel + 11 actor + 9 integration), all passing - Backpressure, FIFO ordering, multi-producer fan-in - Rendezvous semantics, oneshot auto-close - Select with timeout, select3 - Actor spawn/send/ack, multiple messages, stop/destroy

v0.2.36

Released: 2026-03-27 22:02:00 -0400

v0.2.36: dyn Trait dispatch & trait bounds

• New DYN_TRAIT type kind and DynTraitType class in type system
• Parser support for ‘dyn TraitName’ type syntax
• Vtable struct generation (%TraitName_vtable_t) per trait
• Vtable thunk generation (__dyn_TraitName_TypeName_method)
• Vtable constant generation (@TraitName_vtable_TypeName)
• Fat pointer coercion: concrete type -> dyn Trait {data_ptr, vtable_ptr}
• Dynamic dispatch via vtable indirect calls
• Type checker UFCS resolution for dyn trait method calls
• Trait bounds enforcement: func<T: Trait> rejects types without impl
• Split specialization into declare+codegen for trait bound support
• Proper vtable method index lookup using trait_method_order map
• Tests: basic dyn dispatch, multi-method traits, trait bounds

v0.2.35

Released: 2026-03-27 20:22:07 -0400

v0.2.35: Borrow checker syntax (101665i/101665m) & enforcement

Lexer: TOKEN_KW_BORROW_IMM (101665i) and TOKEN_KW_BORROW_MUT (101665m) tokens - Multi-char lexer handler with alphanumeric boundary check - Two-dollar fallback preserves existing $ operator behavior

AST: isBorrowImm/isBorrowMut flags on VarDeclStmt, ParameterNode, FuncDeclStmt Parser: All 7 qualifier-parsing locations updated for 101665i/101665m

Type checker: - Cannot combine 101665i + 101665m on same variable - Cannot combine borrow with wild/wildx - Must have initializer (what are we borrowing?) - Must borrow from named variable (not literal/expression) - Cannot use borrow qualifiers on struct fields (v1 restriction) - Cannot assign through immutable borrow (101665i) - Symbol table tracks isBorrowImm/isBorrowMut

Borrow checker: - 101665i/101665m variables auto-register via recordBorrow() - 1 mutable XOR N immutable rule enforced - Appendage Theory lifetime validation applies

Codegen: - Borrow variables alias original’s storage (no alloca) - Read through borrow loads from original - Write through mutable borrow stores to original - Both ir_generator.cpp and codegen_stmt.cpp updated

Tests: 3 new test files - test_borrow_basic.aria: N-immutable + 1-mutable patterns - test_borrow_comprehensive.aria: aliasing, write-through, independence - test_borrow_errors.aria: documented error case catalog

v0.2.34

Released: 2026-03-27 17:16:50 -0400

v0.2.34: any type + safety_critical_suite fixes + blocked test cleanup

any type implementation: - Added TOKEN_KW_ANY to lexer (token.h, lexer.cpp, token.cpp) - Added TypeKind::ANY + AnyType class to type system (type.h, type.cpp) - isWild/isWildx flags for FFI/JIT interop - Factory: TypeSystem::getAnyType() - Parser recognizes ‘any’ as type keyword - Type checker: any declarations, get/set/resolve via turbofish - box.get::() -> read as int64 (runtime checked) - box.set::(val) -> write int64 value - box.resolve::() -> consuming transform to int64-> - canCoerce() allows any type to coerce to ‘any’ - Codegen: any maps to {ptr, i64} LLVM struct - Auto-boxing on declaration (stack alloc + fat pointer) - get/set/resolve method dispatch in ExprCodegen - Test: tests/test_any_type.aria

safety_critical_suite.aria fixes (41 -> 0 type errors): - Replaced io.print/io.stderr.write with println - Fixed tbb_widen -> tbb_widen_8_to_16 (explicit widening) - Fixed tbb8 + int32 type mismatch (use typed local) - Rewrote LBIM carry chain test (avoid shift on signed) - Added int256/int512/int1024/uint* ERR sentinels to type checker - Commented out defer tests (need runtime module + null)

Blocked test cleanup: - Moved batch02_gemini_audit_fixes.aria to tests/ (compiles clean) - linker_no_main/numeric_types_parser_test.aria compiles with -c

v0.2.33

Released: 2026-03-27 15:45:58 -0400

v0.2.33: trit/nit arithmetic coercion with int literals

• Add balanced type (trit/tryte/nit/nyte) + int32/int64 coercion in arithmetic ops Previously ‘trit + 1’ failed with ‘No common type between trit and int32’ Now balanced type is preserved as result type (matches existing comparison/assignment behavior)
• Fix print(tbb/trit/nit_val) calls in batch02 test to use string messages
• Graduate batch02_gemini_audit_fixes.aria from tests/future/ to tests/ (24/24 pass)
• Version bump to 0.2.33
• Regression: 397/398 tests pass (1 pre-existing: test_complex_simple.aria)

v0.2.32

Released: 2026-03-27 13:52:34 -0400

v0.2.32: Runtime, Stdlib & GPU

• int1024.pow(): binary exponentiation for int128/256/512/1024 with overflow detection
• tbb_widen(): verified working with ERR sentinel propagation
• vec9/tmatrix/ttensor: confirmed existing in codegen
• Vec stdlib: added int16, int32, int64 type variants
• GPU test runner: ptxas validation, –emit-ptx codegen tests, CTest integration
• Version bump to 0.2.32

v0.2.30

Released: 2026-03-27 11:45:51 -0400

v0.2.30: Transitive monomorphization + inline generic struct registration

Compiler changes: - Transitive monomorphization: specialized generic functions that call other generic functions now correctly specialize nested calls. Added analyzeSpecializedBody() in type_checker to walk specialized AST bodies and trigger requestSpecialization for nested generic calls. - Two-pass specialization codegen: ir_generator now forward-declares all specialized functions before generating bodies, fixing cross-reference ordering issues between specialized functions. - Inline generic struct registration: generic struct templates are now pre-registered in genericStructRegistry during the function pre-pass, allowing concrete generic types (e.g. complex) in non-generic function signatures.

Tests: - Promoted test_complex_basic.aria from future/ to misc/ (inline generic struct) - Promoted test_complex_turbofish.aria from future/ to misc/ (transitive mono) - Rewrote and promoted test_dimensional_basic.aria (fix256 physics model) - Removed stale future/ copies of test_fix256_cpu.aria, test_frac_ops.aria (working versions already exist in misc/)

Test suite: 855 total, 735 passing (same 120 pre-existing adversarial failures)

v0.2.29

Released: 2026-03-27 04:52:27 -0400

v0.2.29: string + operator, wildx parser fix, 80 packages, legacy cleanup

v0.2.28.1

Released: 2026-03-26 20:20:56 -0400

v0.2.28.1: Audit deferred tests — promote 3, clean 4 stale duplicates

Test promotions (future/ → tests/misc/): - path_operations.aria: compiles clean, was misplaced in linker_no_main/ - test_parse_dimensional.aria: fixed fix256 init (use fix256_from_float), i32→int32 - test_gpu_kernel.aria: fixed void→NIL, added semicolons/failsafe, compiles CPU+PTX

Stale duplicate cleanup (deleted from future/): - test_safe_nav.aria (dup of tests/test_safe_nav.aria) - test_simd_comprehensive.aria (dup of tests/misc/) - test_simd_final.aria (dup of tests/misc/) - test_no_at.aria (dup of tests/misc/)

Regression: 841 tests, 838 pass (99%). +3 new, 0 regressions. 16 files remain in future/ (GPU backend, transitive monomorphization, etc.)

v0.2.28

Released: 2026-03-26 19:51:58 -0400

v0.2.28: Fix fix256 ABI, wire numeric types, add tests (838 tests, 835 pass)

fix256 deterministic fixed-point — fully wired: - Fixed SysV x86-64 ABI for 32-byte struct passing (byval + sret) - All arithmetic operators (+, -, *, /) use sret for return + byval for params - All 7 comparison operators (==, !=, <, <=, >, >=, <=>) use byval for params - Conversion functions (from_int, to_int, from_float, to_float) ABI-fixed - generateLBIMBinaryOp fixed for all large struct types (>16 bytes)

frac32 fraction type — function-call API works: - frac32_from_parts, add/sub/mul/div, neg, cmp, to_int/to_float all compile

New tests: test_fix256_cpu, test_fix256_division, test_frac_ops

v0.2.27

Released: 2026-03-26 13:36:03 -0400

v0.2.27: Generic struct type inference for complex number stdlib

Fix GenericResolver::inferTypeArgs() to handle compound generic types like complex<T> in function parameters. Previously only simple T params could infer type arguments. Now extracts T from monomorphized struct argument names (e.g., _Aria_M_complex_hash_int32 -> T=int32).

Changed: src/frontend/sema/generic_resolver.cpp - Added compound generic type inference in Phase 1 - Parses monomorphized struct names to extract concrete type args - Supports single-param generic structs (complex<*T>, etc.)

Unblocked tests (moved from future/ -> misc/): - test_complex_operations.aria: generic complex API (new/add/sub/mul/conjugate) - test_complex_generic.aria: multi-type complex implementation (int32/int64/flt64)

Regression: 832/835 passing (99%), 3 pre-existing failures unchanged.

v0.2.26

Released: 2026-03-26 13:13:31 -0400

v0.2.26: Module Resolution — Restore std symlink, add mem.aria, unblock 4 tests

v0.2.25

Released: 2026-03-26 12:55:56 -0400

v0.2.25: SIMD Builtins — Fix float vector codegen, unblock 7 SIMD tests

v0.2.24

Released: 2026-03-26 12:17:10 -0400

v0.2.24: HashMap Stdlib Integration

• Added map_i32_i64_* and map_i8_i8_* typed C wrappers to collection_helpers.cpp (new/insert/get/has/remove/length/clear/free for each specialization)
• Rewrote all 3 stdlib hashmap libraries (int32_int64, int64_int64, int8_int8):
  • All functions now pub for use imports
  • nil returns instead of void for non-extern functions
  • Uses typed C wrappers that pass values by value (no pointer casts)
  • Added get-with-out-param pattern (returns 1/0 found status)
  • Added remove-with-status pattern (returns 1/0)
• Rewrote all 3 hashmap test files with proper use imports, failsafe, pub main
• Moved hashmap tests from tests/future/ to tests/misc/ (all passing)
• 819/822 tests passing (99%), same 3 pre-existing failures

v0.2.23

Released: 2026-03-26 11:43:27 -0400

v0.2.23: Trait System — fix parsing hang, enable trait+impl+UFCS

• Fix infinite loop in parseTraitDecl(): accept ‘=’ after ‘func:name’ (RFC syntax: func:method = RetType(params)) in addition to ‘:’
• Add progress guard to inner parameter parsing loop to prevent hangs on malformed trait method signatures
• Promote test_trait_minimal.aria from future/compiler_crash/ to misc/
• New tests: test_trait_impl_basic, test_trait_ufcs, test_trait_multi, test_trait_area — all verifying trait definition, impl with method bodies, mangled function calls, and UFCS dispatch
• 815/818 tests passing (99%), no regressions
• Version bump to 0.2.23

v0.2.22

Released: 2026-03-26 11:17:45 -0400

v0.2.22: Optional Types — T?, ?., ? unwrap

Parser: - Custom type optional declarations (User?:name) now recognized

Type checker: - Member access on Optional types handles both . and ?.

IR codegen: - value_types registration for Optional variables (strip ?, wrap OptionalType) - mapType() supports TypeKind::OPTIONAL → { i1 hasValue, T value } - MEMBER_ACCESS for Optional struct types with safe navigation blocks (check hasValue, unwrap inner struct, access field, return Optional) - UNWRAP ? operator auto-detects Optional {i1,T} vs Result {T,ptr,i1} - Struct literal field stores: truncate/extend to match field types (fixes i64-into-i32 miscompilation under optimizer)

Tests: 810/813 passing (3 pre-existing failures) Promoted: test_safe_nav.aria from future/

v0.2.21

Released: 2026-03-26 10:40:05 -0400

v0.2.21: Codegen crash fixes — struct mutation, Vec, optional wrapping, address-of

Fixes 7 compiler crashes (segfaults/aborts during LLVM IR codegen):

Codegen fixes in ir_generator.cpp: - Generic type name mangling in mapTypeFromName(): Vec -> Vec_int8 to match TypeChecker’s structCache keys - Duplicate LLVM struct type prevention: getTypeByName() check before create() - Optional unwrapping in struct field assignment: {i1, T} -> T when field expects T (prevents 16-byte store into 8-byte ptr slot) - VAR_DECL generic name mangling for struct lookup

Codegen fix in codegen_expr.cpp: - Address-of (@) operator for function parameters: spill SSA value to temporary alloca when operand is not already in memory

Optional wrapping in pass() statement (ir_generator.cpp): - When return type is Result<Optional> and pass() value is raw T, wrap value into {i1 true, T} before placing in Result struct

Tests promoted from future/compiler_crash/ to main suite (7): - test_struct_field_mut, test_hashmap_basic, test_vec_final, test_vec_combined, nil_vs_null, nil_optional_comprehensive, nil_vs_null_comprehensive

Zero regressions: 174/174 baseline tests unchanged.

v0.2.19

Released: 2026-03-26 09:18:56 -0400

v0.2.19: Fix generic monomorphization type substitution

The keystone generic bug: type parameters in compound types (Pair, Vec, etc.) were not being substituted during monomorphization. The hash was computed with unsubstituted ‘T’ instead of the concrete type, causing definition-site and use-site mangled names to differ.

Root cause: cloneAndSubstitute and substituteTypes only handled simple *T or T type references. Compound types like Pair in return types and local variable declarations were left unsubstituted.

Fix: Added substituteTypeNode() method that recursively substitutes type parameters inside any type AST node (SimpleType, GenericType, ArrayType, PointerType, OptionalType). Updated cloneAndSubstitute, substituteTypes for VarDeclStmt, ParameterNode, and FuncDeclStmt to use it.

• 0 regressions (251/251 baseline tests pass)
• test_generic_struct promoted from future/ to main suite
• test_complex_turbofish: hash mismatch fixed, raw() added (blocked on separate complex_is_err codegen issue)

v0.2.18

Released: 2026-03-26 08:36:58 -0400

v0.2.18: Test-side fixes — 19 tests promoted from future/ to main suite

Promoted 19 tests from tests/future/ to tests/ (all compile+run, exit 0):

Top-level future/ → tests/ (5): - test_instance_simple: Added Counter_create function + raw() wrap - test_instance_syntax: Rewrote with standalone functions (validates desugaring) - test_static_simple: Added Counter_nextId function + raw() wrap - test_static_no_parens: Same (validates auto-call desugaring) - test_stdlib_import: Rewrote with correct Aria syntax

linker_no_main/ → tests/ (14): - helper, helper_multi, math, math_utils, utils: Added main() - test_different_names, test_only_float, test_order_float_first: Added main() - test_simd_same_params, test_simple_reduction, test_simd_select: Added main() - test_gpu_minimal: Added main() - test_parameter_scope_fix: Fixed return→pass(), added main() - test_simd_reductions: Fixed return→pass()

Other fixes: - batch02_gemini_audit_fixes: Renamed reserved word ‘unknown’→‘unk_val’ (parse error fixed, 8 type errors remain — blocked on trit/nit runtime) - test_hashmap_basic: Added raw() wrap (compiles now, crashes in codegen → moved to compiler_crash/)

Discovery: instance() and Type.Member desugaring already work! The compiler correctly transforms instance(args)→Counter_create(args) and Counter.nextId()→Counter_nextId(). Tests just needed target functions.

Remaining in future/: 45 files (22 top-level, 12 compiler_crash, 5 linker, 6 modules)

v0.2.17

Released: 2026-03-26 06:26:48 -0400

v0.2.17: 100% positive test pass rate (125/125)

Test fixes: - test_wave9: Fix import syntax (use “wave.aria”.*;), remove raw() on use-imported functions (auto-unwrap), restore nit variable declarations - test_contract_ensures: Fix Result type usage (ensures returns plain type) - test_contracts_basic: Fix ensure/require contract patterns, remove incorrect raw() in pass(), use plain int return types with ensures - test_void_check: Replace extern printf with println, add raw() unwrap - test_reassignment: Replace extern puts with println, add failsafe - seed_struct_array_field: Use named field syntax with separate array variable - test_write_direct: Replace raw write() syscall with stdout_write builtin

Deferred to tests/future/ (need compiler features): - test_vec_methods: Needs Vec@ reference-to-generic parser support - test_vec_phase3: Needs Vec monomorphization - test_generic_struct: Needs monomorphization hash consistency fix

v0.2.16

Released: 2026-03-26 05:35:36 -0400

v0.2.16: Spec Compliance, Bug Fixes & Test Hardening

Test suite: 633/642 positive = 98.6% pass rate (up from 74.2%) 62 tests deferred to future/ for 0.3+ features 158 negative tests, 9 remaining positive failures (compiler-side)

This is the final 0.2.x spec compliance release.

v0.2.15

Released: 2026-03-26 02:57:36 -0400

Release v0.2.15 — Ecosystem, Distribution & Polish

v0.2.14

Released: 2026-03-26 01:53:52 -0400

v0.2.14: Documentation, Testing & Code Quality

• 486 documentation files corrected across aria-docs
• Syntax fixes: fn→func:, <<→print(), eprint→stderr_write, ${}→&{}
• Full test audit: 862 tests, 640 passing (74.2%)
• CONTRIBUTING.md added to all 15 repos
• VS Code extension grammar rewritten
• 93 TODO annotations documented, 0 FIXMEs found

v0.2.13

Released: 2026-03-25 23:12:31 -0400

v0.2.13: WebAssembly compilation target

v0.2.12

Released: 2026-03-25 21:18:24 -0400

v0.2.12 — Comptime, Inline/Noinline, Preprocessor Enhancements, Borrow Checker Suggestions

v0.2.11

Released: 2026-03-25 17:34:26 -0400

Aria v0.2.11 — Threading, OS Components, AI Filesystem, Hexstream

v0.2.10

Released: 2026-03-25 15:41:10 -0400

v0.2.10: AI/ML Ecosystem & Communication Protocol

New packages: - aria-transformer (10/10 tests) - aria-mamba (10/10 tests) - aria-jamba (10/10 tests) - aria-looping (10/10 tests) - aria-tensor (12/12 tests) - aria-cuda (10/10 tests) - aria-uacp (12/12 tests)

Self-improving specialist training loop

v0.2.9

Released: 2026-03-25 13:18:19 -0400

v0.2.9: Server Platform

HTTP server stack with Express-style routing and 6 middleware libraries. 154+ tests across all server packages.

Compiler fixes: - Borrow checker false positive on deallocator-named void externs - FFI string return ABI for AriaString structs

v0.2.8

Released: 2026-03-25 05:25:16 -0400

docs: update README for v0.2.8 — repo reorganization, 59 packages, new status, updated roadmap and project structure

v0.2.7

Released: 2026-03-24 17:00:59 -0400

v0.2.7: Six-Stream I/O & POSIX Tools

v0.2.6

Released: 2026-03-24 14:42:50 -0400

Merge branch ‘dev’

v0.2.5

Released: 2026-03-24 09:54:12 -0400

v0.2.5: Documentation, CI/CD & Infrastructure

• GitHub Actions CI pipeline (build, test, .deb packaging)
• Issue templates (bug report, feature request, compiler crash) + PR template
• CONTRIBUTING.md contributor guide
• Compiler architecture manual (695 lines)
• Man pages for ariac, aria-ls, aria-pkg, aria-doc, aria-dap
• Documentation code examples tested and fixed (7 doc bugs)
• Specialist model evaluation and strategy documented
• README updated to v0.2.5

v0.2.4

Released: 2026-03-24 07:57:35 -0400

Aria v0.2.4: async/await error propagation, arrays-in-structs, code quality

v0.2.3

Released: 2026-03-24 04:23:55 -0400

v0.2.3: Database Client Libraries

New Features: - SQLite client library (aria-sqlite) — 34 tests - PostgreSQL client library (aria-postgres) — 40 tests - MySQL client library (aria-mysql) — 44 tests - Redis client library (aria-redis) — 53 tests - DATABASE_GUIDE.md — comprehensive usage documentation - 171 total database test assertions, all passing

Stability: - 8/8 fuzzer crash inputs now handled gracefully - Grammar fuzzer: 500/500 clean - Mutation fuzzer: 6,980 mutations, 0 crashes - Fullstack fuzzer: 200 tests, 0 crashes

AI: - V5 specialist model retained as production - V6 training corpus created (2,715 examples) for future improvement

v0.2.2

Released: 2026-03-23 20:22:05 -0400

v0.2.2: Ecosystem Expansion

• GUI toolkit wrappers (GTK4, SDL2, raylib)
• 9 utility libraries (39 packages total)
• V5 specialist model (87% accuracy, +16 over V3)
• Tooling: LSP enhancements, MCP server, aria_make, debugger
• Debian package (17MB .deb)
• Repository reorganization (10 repos)
• Float128 crash fix (fuzzer-discovered)
• Section 4 compiler testing: 9/10 edge-case programs compile, 0 crashes

v0.2.1.1

Released: 2026-03-22 19:58:56 -0400

v0.2.1.1: aria-dap debugger, DWARF debug info, VS Code debug integration

v0.2.1

Released: 2026-03-22 18:32:12 -0400

v0.2.1 — Developer Experience & Tooling

• aria-pkg: fixed registry/metadata/tarball, added search/pack/directory-install (27/27 packages)
• aria-doc: fixed unknown.html — parser rewritten for Aria syntax (435 pages)
• aria-ls: AST-based hover, goto-definition, completion (keywords+types+symbols)
• install.sh: one-command build+install, tested on clean Linux Mint 22.3 VM
• VS Code extension: v0.2.1 with updated bundled aria-ls
• Benchmarks: 3 Aria vs C benchmarks with runner script
• aria-mcp and aria-safety verified working
• CMakeLists.txt and install.sh fixed for clean-machine builds

v0.2.0

Released: 2026-03-22 12:22:50 -0400

Aria v0.2.0 — Self-Hosting Compiler Release

Highlights: - Self-hosting compiler: 5 modules (lexer, parser, type checker, supporting passes, pipeline) with 220 tests - Improved error diagnostics with ‘Did you mean?’ suggestions and accurate source locations - License changed from AGPL v3 to Apache 2.0 - 7 critical codegen bugs fixed - Donation pages removed - 432+ passing test files

v0.1.0

Released: 2026-03-20 22:27:40 -0400

v0.1.0: Feature freeze — stable compiler and stdlib for Nikola

Compiler: - All 27 catalogued bugs fixed, zero workarounds - Borrow checker with full wild pointer tracking - Safety-critical validation (IEEE 754, overflow, determinism, TBB) - 681 test files, all passing

Standard Library: - string, string_builder, string_convert (45+ tests) - collections: Vec, VecI32, VecF64, Map, Set, Graph (70 tests) - io: file streams (9 tests) - math: transcendentals (19 tests) - linalg: Vec2, Vec3, Mat2x2, Mat3x3 (19 tests) - json: builder, parser, encoder (48 tests) - toml: builder, parser, encoder (40 tests) - binary: buffer serialization (25 tests) - net: TCP client/server (15 tests)

Ecosystem: - 27 aria_packages (543+ assertions) - wave/wavemech, complex, quantum, atomic, dbug

v0.0.14

Released: 2025-12-11 22:19:07 -0500

Release v0.0.14: Tensor Types - Phase 1 Complete

All core type systems implemented: - TBB types with sticky errors - Balanced ternary/nonary - SIMD vector types - N-dimensional tensors

22/22 tensor tests passing

v0.0.13

Released: 2025-12-11 22:14:30 -0500

Release v0.0.13: Vector Types with SIMD Support

Phase 1.3 Complete - Vec2/3/4 float vectors (32-bit) - DVec2/3/4 double vectors (64-bit) - IVec2/3/4 integer vectors (32-bit) - Full SIMD acceleration via LLVM FixedVectorType - 25/25 unit tests passing - Runtime: 640 lines - Codegen: 330 lines SIMD-optimized - Compiler binary: 58MB

v0.0.12

Released: 2025-12-11 21:51:57 -0500

v0.0.12 - Balanced Nonary Arithmetic Complete

Major Features: - Complete balanced nonary type system (nit, nyte) - 5 nits packed in uint16 (59,049 value range) - Biased-radix encoding with monotonic mapping - Full arithmetic support (+, -, *, /, %, negation) - 26/26 unit tests passing - Direct hardware comparison optimization

Implementation: - 360 lines runtime (NonaryOps class) - 242 lines LLVM codegen (NonaryLowerer) - 91 lines C runtime wrappers - Sticky error propagation

Files Added: - src/backend/nonary_ops.{h,cpp} - src/backend/codegen_nonary.{h,cpp} - src/backend/nonary_runtime.cpp - docs/BALANCED_NONARY_STATUS.md

Research: Gemini-assisted (research_003, 59KB report) Timeline: 3.5 hours (predicted: 3-4 hours) Phase: 1.2.2 COMPLETE

v0.0.11

Released: 2025-12-11 21:10:38 -0500

v0.0.11 - Balanced Ternary Arithmetic Complete

Major Features: - Complete balanced ternary type system (trit, tryte) - 10 trits packed in uint16 (59,049 value range) - Split-byte encoding with O(1) operations - Full arithmetic support (+, -, *, /, negation) - 20/20 unit tests passing - 640 lines of documentation

Implementation: - 561 lines runtime (TernaryOps class) - 456 lines LLVM codegen (TernaryLowerer) - 256-entry LUT for unpacking - Sticky error propagation

Files Added: - src/backend/ternary_ops.{h,cpp} - src/backend/codegen_ternary.{h,cpp} - tests/ternary/test_ternary_ops.cpp - docs/BALANCED_TERNARY_{STATUS,FINAL_REPORT}.md

Research: Gemini-assisted (research_002, 54KB report) Timeline: 1 day (planned: 2-3 weeks)

v0.0.10

Released: 2025-12-11 14:40:36 -0500

v0.0.10: TBB arithmetic with sticky error propagation

• Complete TBB type system (tbb8/16/32/64)
• Overflow detection with LLVM intrinsics
• ERR sentinel propagation (-128 for tbb8)
• All arithmetic operations implemented
• Gemini research responses integrated