{"id":50730976,"url":"https://github.com/alternative-intelligence-cp/nitpick","last_synced_at":"2026-06-10T08:32:04.561Z","repository":{"id":327166626,"uuid":"1107269122","full_name":"alternative-intelligence-cp/nitpick","owner":"alternative-intelligence-cp","description":"Nitpick Programming Language — systems language built for safety, determinism, and AI-native applications. LLVM backend, 80 packages, LSP, DAP debugger, GPU codegen.","archived":false,"fork":false,"pushed_at":"2026-06-02T02:49:03.000Z","size":83748,"stargazers_count":2,"open_issues_count":0,"forks_count":1,"subscribers_count":1,"default_branch":"main","last_synced_at":"2026-06-02T04:21:56.877Z","etag":null,"topics":["ai","compiler","gpu","language-server","llvm","nitpick","programming-language","systems-programming"],"latest_commit_sha":null,"homepage":"https://www.ai-liberation-platform.org","language":"C++","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"apache-2.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/alternative-intelligence-cp.png","metadata":{"files":{"readme":"README.md","changelog":"CHANGELOG.md","contributing":"CONTRIBUTING.md","funding":null,"license":"LICENSE.md","code_of_conduct":null,"threat_model":null,"audit":"AUDIT_v0.15.0.md","citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2025-11-30T22:17:16.000Z","updated_at":"2026-06-02T02:49:08.000Z","dependencies_parsed_at":null,"dependency_job_id":"66c63b92-9516-4041-a01a-07b1d5112916","html_url":"https://github.com/alternative-intelligence-cp/nitpick","commit_stats":null,"previous_names":["alternative-intelligence-cp/aria","alternative-intelligence-cp/nitpick"],"tags_count":374,"template":false,"template_full_name":null,"purl":"pkg:github/alternative-intelligence-cp/nitpick","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/alternative-intelligence-cp%2Fnitpick","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/alternative-intelligence-cp%2Fnitpick/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/alternative-intelligence-cp%2Fnitpick/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/alternative-intelligence-cp%2Fnitpick/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/alternative-intelligence-cp","download_url":"https://codeload.github.com/alternative-intelligence-cp/nitpick/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/alternative-intelligence-cp%2Fnitpick/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":34144679,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-26T15:22:16.424Z","status":"online","status_checked_at":"2026-06-10T02:00:07.152Z","response_time":89,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["ai","compiler","gpu","language-server","llvm","nitpick","programming-language","systems-programming"],"created_at":"2026-06-10T08:32:03.336Z","updated_at":"2026-06-10T08:32:04.552Z","avatar_url":"https://github.com/alternative-intelligence-cp.png","language":"C++","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Nitpick Programming Language v0.40.7 (formerly Aria)\n\n\u003cp align=\"center\"\u003e\n    \u003cimg src=\"assets/nitpick_logo.png\" alt=\"Nitpick logo: raccoon holding a magnifying glass\" width=\"280\"\u003e\n\u003c/p\u003e\n\n\u003e 🚧 **Rebrand in progress:** Aria is becoming **Nitpick**. The `v0.18.0` tag is\n\u003e preserved as the final Aria-named K Framework semantics milestone. This repo\n\u003e still uses Aria names while the migration is underway; history, tags, and\n\u003e compatibility paths will be preserved. See [REBRAND_TO_NITPICK.md](REBRAND_TO_NITPICK.md).\n\n[![License: Apache 2.0](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://www.apache.org/licenses/LICENSE-2.0)\n[![CI](https://github.com/alternative-intelligence-cp/aria/actions/workflows/ci.yml/badge.svg)](https://github.com/alternative-intelligence-cp/aria/actions/workflows/ci.yml)\n\n**The Alternative Intelligence Liberation Platform presents: A systems programming language built for safety, determinism, and AI-native applications**\n\n\u003e ⚠️ **[READ THIS FIRST: SAFETY.md](SAFETY.md)** — No language is truly safe on its\n\u003e own. Nitpick makes dangerous operations **explicit** — you can't shoot yourself in\n\u003e the foot accidentally, but you can do it intentionally. Understand the safety\n\u003e contract before using `wild`, `async`, `@`, `extern`, or `wildx`.\n\n---\n\n## Current Status (June 2026)\n\n**Released: v0.40.7 — Conditionals (`if`/`else if`/`else` + the `is` ternary) deep-dive complete (COND-DEC-001–014)**\n\nThe v0.40.x cycle hardened Nitpick's two conditional surfaces: the\n`if`/`else if`/`else` statement chain and the `is (cond) : a : b` inline\nvalue-ternary. All COND-DEC items resolved across v0.40.0–v0.40.7. The headline\nfix taught the warning and borrow analyses to see through the `is` ternary\n(`TERNARY` case added to `warnings.cpp` `collectIdentifiers` and\n`borrow_checker.cpp` `checkExpression`), so a variable or borrow used only\ninside an `is` arm is no longer a false `[unused-variable]`. Two more codegen /\nanalysis bugs fixed: a mixed-width PHI verification failure when an `is`\nternary's two arms had different integer widths (now the narrower arm is\nsign-extended to the common type before the PHI), and `isTerminalStatement`\nfailing to recognize `exit` so dead code after a branch `exit` went unflagged.\nFour diagnostics minted: `ARIA-IS-001` (incompatible `is` arms), `ARIA-IF-001`\n(stray `else`/`else if`), `ARIA-IF-002` (assignment `=` used as a condition →\nsuggest `==`), and `ARIA-IF-003` (`if` used in value position → points at `is`\nand `pick`+`give`, ratifying that `if` is a statement and never an expression).\n40 bug regressions (bug951–bug990), K core tests 229–235 (native `is` ternary\ngrammar `is ( Exp ) : Exp : Exp` with `strict(1)` condition and the two\nreduction rules), and an 8-chapter `guide/conditionals/` cookbook. CTest\n201/201, K core 235/235.\n\n**Previous stable release: v0.39.6 — `when` / `then` / `end` loop-completion construct deep-dive complete (WHEN-DEC-001–012)**\n\nThe v0.39.x cycle made `when` a complete, sound, well-diagnosed\nloop-completion construct: a `while`-style loop carrying optional `then` (clean\nexit) and `end` (short-circuit) completion clauses. All WHEN-DEC items resolved\nacross v0.39.0–v0.39.6: the headline broke-flag codegen fix routing `break` to\n`end` and clean exit to `then`; `continue` semantics (re-tests the condition,\ndoes not mark completion); optional clauses (`then`-only, `end`-only, bare\n`when`); the zero-iteration rule (a `when` that never completes an iteration\nroutes to `end`, not `then`); borrow-checker and unused-variable coverage of\nall three blocks; arbitrarily nested `when` with innermost binding and labeled\n`break(label)` / `continue(label)` escape; and three new diagnostics\n`ARIA-WHEN-001..003` (stray `then`/`end`, duplicate clause, mis-ordered\n`then`-after-`end`). 19 bug regressions (bug923–bug941), K core tests 223–228\n(with a `completed` flag modeling the then-vs-end decision), and an 8-chapter\n`guide/when/` cookbook. CTest 195/195, K core 228/228, K proofs 14/14.\n\n**Previous stable release: v0.38.8 — Loop constructs deep-dive cycle complete (LOOP-DEC-001–015)**\n\nThe v0.38.x cycle made every loop form a complete, sound, well-diagnosed\nconstruct. All 15 LOOP-DEC items resolved across v0.38.0–v0.38.8: the five loop\nforms (`while`, `loop(start,limit,step)`, `till(limit,step)`, `for x in ...`,\nC-style `for`), bare and labeled `break`/`continue` (loop labels via the\n`label:` prefix, with full IR codegen so `break(outer)` / `continue(outer)`\nsteer an enclosing loop), break/continue transparency through `pick` arms,\n`if`, and bare blocks (while `fall` stays pick-scoped), loan release on `break`\nand liveness across `continue`, and loop `invariant` interaction with early exit\nunder both Z3 (`--verify-contracts`) and runtime (`--debug-contracts`) checking.\nFive new diagnostics `ARIA-LOOP-001..005` (out-of-loop break/continue,\ndead-code-after, unknown label, non-iterable, duplicate label). Two latent\ncodegen bugs fixed: a PHI-node mismatch on counted-`loop` invariants under\n`--debug-contracts`, and an infinite loop when a scalar parameter is mutated\ninside its own loop condition. 50 bug regressions (bug860–bug909), K core tests\n216–222, and a 9-chapter `guide/loops/` cookbook. CTest 190/190, K core\n222/222, K proofs 14/14.\n\n**Previous stable release: v0.37.8 — `pick` / `fall` dispatch deep-dive cycle complete (PICK-DEC-001–015)**\n\nThe v0.37.x cycle made `pick` a complete, sound, well-diagnosed dispatch\nconstruct. All 15 PICK-DEC items resolved across v0.37.0–v0.37.8: integer\ndispatch with LLVM jump-table lowering, enum/tagged exhaustiveness, string\ndispatch via `npk_string_equals`, `trit` finite domain + `tbb` balanced-binary\nsticky-ERR, label-checked explicit `fall` (`ARIA-PICK-004`), nested picks,\n`where` arm guards (new keyword), and `pick` as a value-yielding **expression**\nwith `give` (new keyword). Four new diagnostics `ARIA-PICK-001..004` (the `_`\nwildcard hint, duplicate arm, unreachable arm, bad `fall` label). 52 bug\nregressions (bug808–bug859), K core tests 211–215, and a 9-chapter\n`guide/pick/` cookbook. CTest 181/181, K core 215/215, K proofs 14/14.\n\n**Previous stable release: v0.36.7 — Enum deep-dive cycle complete (ENUM-DEC-001–015)**\n\nThe v0.36.x cycle fully delivered the Aria/Nitpick enum surface:\nplain C-style enums (foundation since v0.2.39) and tagged-union variants\n(variants carrying typed payload fields). All 15 ENUM-DEC items resolved across\nv0.36.0–v0.36.7: pick on enum-typed vars, enum as struct field / fn param / return,\ndiscriminant cast, derive(Display) and derive(Eq) for plain and tagged enums,\nnested enum payloads (enum variant whose payload is another enum), and Result\u003cT\u003e\ninterop. 10 bug regression tests (bug798–bug807), K core tests 208–210.\n\n**Previous stable release: v0.35.7 — Arrays / Structs / Objects audit complete**\n\nThe v0.35.x cycle audited and locked the three primary aggregate types:\nslice syntax (`arr[lo..hi]` half-open), multi-dim canonical form (`arr[i][j]`),\narray iteration (`for elem in arr`), struct FFI ABI documentation, struct `==`\nregression matrix, and `dyn Trait` as a struct field (OBJ-DEC-002).\n\nThe previous v0.34.x cycle audited and locked the failsafe and Design-by-Contract\nsurface: `failsafe`, `!!!`, `exit`, `requires`, `ensures`, `result`,\n`invariant`, `prove`, `assert_static`, and `limit\u003cRules\u003e`. The cycle ratified\nthe endpoint rules for `main`/`failsafe`, consolidated failsafe code allocation\nin `stdlib/failsafe_codes.npk`, wired contract/proof obligations into the Z3\nbackend, preserved runtime fallbacks where intended, and added the canonical\n`aria-docs/guide/dbc/` cookbook.\n\nThe previous v0.33.x cycle audited and locked the Result-handling surface:\n`pass`, `fail`, `?`, `??`, `?!`, `?|`, `defaults`, `raw`, `drop`, `_?`,\n`_!`, safe navigation, `Result\u003cNIL\u003e`, `await` parser shape, and contextual\n`catch`. The cycle reconciled stale docs with shipped semantics: `?` is\nfallback unwrap, `??` is Optional/pointer null coalescing, source-level `?!`\nis emphatic fallback unwrap rather than failsafe dispatch, `_?` / `_!` are\nprefix shorthands, and `catch` remains a contextual identifier-compatible\nResult handler.\n\nThe previous v0.32.x cycle audited and locked the pointer/cast surface that\nsits on top of the memory-interplay work: `-\u003e`, `\u003c-`, `.`, `@`, checked\ncasts, `@cast_unchecked\u003cT\u003e`, unsafe pointer arithmetic behind\n`stdlib/unsafe.npk`, and NULL-dereference failsafe sentinel 46.\n\nThe previous v0.31.x cycle was a five-phase sweep across every memory, borrow,\nasync, trait, and special-value surface added since v0.26.x:\n\n- **Phase 1 (v0.31.0.x)** — `async`/`await` borrow-checker hardening:\n  borrows must release before suspension points (ARIA-041), per-frame\n  loan tracking across `select!`/`join!`/`spawn`, K-Framework rules for\n  await suspension, 9-chapter `guide/async/` cookbook.\n- **Phase 2 (v0.31.1.x)** — `trait` / `impl` / `dyn T` polish: dyn\n  dispatch through borrowed receivers, trait-method `$$i` / `$$m`\n  receivers, `dyn Trait` borrow rules (ARIA-042/043), trait-object\n  exhaustiveness, 9-chapter `guide/traits/` cookbook.\n- **Phase 3 (v0.31.2.x)** — Special-value reconciliation: unified\n  `fixed` / `NIL` / `NULL` / `ERR` / `unknown`, `Result\u003cT\u003e` + `fail`\n  end-to-end, exhaustiveness for special-value picks (ARIA-044/045/046),\n  K core proofs for Result `?`/`!` propagation, 7-chapter\n  `guide/special-values/` cookbook.\n- **Phase 4 (v0.31.3.x)** — Cross-module summary visibility,\n  transitive ARIA-032 chains, RAII / Drop auto-emission for `wild`\n  bindings (ARIA-049, ARIA-050), array-bounds runtime check with\n  `--no-bounds-checks` opt-out, K proof depth-4 pin-address-stable.\n- **Phase 5 (v0.31.4.x)** — Polish / QoL: ARIA-022 diagnostic hints\n  (W-01), guide cross-reference sweep, README refresh, cycle close.\n- **v0.31.5.x — Handle\u003cT\u003e per-binding auto-free (W-03)** — RAII\n  parity for per-`Handle\u003cT\u003e` bindings: opting in via\n  `use \"drop.npk\".*;` now auto-emits `npk_handle_free(h)` for\n  every `Handle\u003cT\u003e:h = HandleArena.alloc(a, N);` binding at scope\n  end, on top of the existing per-arena `npk_handle_arena_destroy`\n  (v0.29.5). Pass-move (`pass h`) skips the auto-free in the\n  originating frame (HANDLE-DEC-006). The original `ARIA-051`\n  warning (explicit `HandleArena.free(h)` on a RAII-managed\n  binding) was **promoted to a hard `ARIA-022` error and\n  retired in v0.31.6.4** once `nodrop` (W-04) provided a\n  precise per-binding opt-out. The fifth sentinel struct\n  `NitpickHandleRaii` lands in `stdlib/drop.npk` alongside its\n  per-region flag `handle_raii_enabled`.\n\n**Current validation snapshot:** CTest **158/158** (release build,\nexcluding direct `k_semantics_*` aggregate wrappers);\n`k_semantics_core` **201/201** under K Framework v7.1.320;\n`k_semantics_proofs` **14/14** proof modules; **bug001 – bug712**\nregression bug fixtures; **103 packages**; **74 stdlib modules**.\n\n**v0.34.x highlights (this cycle):**\n- **v0.34.0** — kickoff audit for the failsafe + DbC marathon;\n  FAILSAFE-DEC-001..005 and DBC-DEC-001..008 seeded.\n- **v0.34.1** — `failsafe` endpoint hardening (`ARIA-068`), `!!!`\n  dispatch polish, `stdlib/failsafe_codes.npk`, and K core 193–194.\n- **v0.34.2** — `exit` scope enforcement (`ARIA-069`) and proof #14\n  `failsafe-dispatch-proofs.k`; K core 195.\n- **v0.34.3** — `requires` / `ensures` Z3 obligation locking,\n  `result` pseudo-variable scoping (`ARIA-070`), and K core 196–197.\n- **v0.34.4** — `invariant` loop annotations with ARIA-071/072,\n  Z3 entry obligations, runtime debug checks, and K core 198.\n- **v0.34.5** — hard `prove` obligations with ARIA-073/074,\n  automatic verification, `--debug-z3` SMT-LIB dumps, and K core 199.\n- **v0.34.6** — CTFE-driven `assert_static` (`ARIA-075`),\n  `limit\u003cRules\u003e` compile-time and runtime locking (`ARIA-076`, failsafe\n  code 49), and K core 200–201.\n- **v0.34.7** — `guide/dbc/` cookbook, README snapshot, and final\n  umbrella cycle audit.\n\n**v0.33.x highlights (previous cycle):**\n- **v0.33.0** — kickoff audit for the Result-handling marathon;\n  RESULT-DEC-001..014 seeded and stale docs/source drift identified.\n- **v0.33.1** — `expr ? fallback` ratified as fallback unwrap,\n  nested explicit fallback locked, and `await work() ? fb` parser shape\n  fixed; K core 183–184.\n- **v0.33.2** — `??` ratified as Optional/pointer null coalesce,\n  `?|` / `defaults` equivalence locked, and defaults precedence captured;\n  K core 185–186.\n- **v0.33.3** — source-level `expr ?! fallback` ratified as emphatic\n  Result fallback unwrap, `?.` safe navigation returns Optional fields,\n  and Result receivers are rejected for `?.`; K core 187–188.\n- **v0.33.4** — `_?` / `_!` desugar parity locked: `_?` is `drop`,\n  `_!` is `raw`; K core 189–190.\n- **v0.33.5** — contextual `result catch (err) { handler }` implemented\n  end-to-end while preserving `catch` as a valid identifier; K core\n  191–192 and proof #13 added.\n- **v0.33.6** — `guide/result/` cookbook, README snapshot, and final\n  umbrella cycle audit.\n\n**v0.32.x highlights (previous cycle):**\n- **v0.32.0** — kickoff audit for the pointer/cast marathon;\n  `POINTER-DEC-001`..`017` seeded.\n- **v0.32.1** — `-\u003e` type + pointer-member expression audit; depth-3 chain\n  read/write/mixed-chain regressions and K core 176.\n- **v0.32.2** — `\u003c-` whole-dereference semantics; primitive/struct/expression\n  deref regressions and K core 177.\n- **v0.32.3** — `@` address-of and pin alias matrix; stack/pin write-through\n  locks and K core 178–179.\n- **v0.32.4** — checked cast warning matrix: `ARIA-062` narrowing,\n  `ARIA-063` signedness, `ARIA-064` float precision, plus\n  `@cast_unchecked\u003cT\u003e` suppression and K core 180–181.\n- **v0.32.5** — `stdlib/unsafe.npk`, `@ptr_add\u003cT\u003e`, `@ptr_sub\u003cT\u003e`,\n  `ARIA-065`/`ARIA-066` region policy, `ARIA-067 @NULL`, NULL failsafe\n  sentinel 46, generic wrapper hygiene, and K core 182.\n- **v0.32.6** — FFI ABI docs, `guide/memory/pointers.md`, README snapshot,\n  and umbrella cycle audit.\n\n**Previous v0.31.x highlights:**\n- **v0.31.0.0–v0.31.0.7** — `async`/`await` borrow-checker (Phase 1).\n- **v0.31.1.0–v0.31.1.8** — `trait` / `dyn T` polish (Phase 2).\n- **v0.31.2.0–v0.31.2.11** — Special-value reconciliation (Phase 3).\n- **v0.31.3.0–v0.31.3.10** — Cross-module / RAII / bounds-check (Phase 4).\n- **v0.31.4.0–v0.31.4.2** — Polish / cycle-close (Phase 5).\n- **v0.31.5.0–v0.31.5.4** — Handle\u003cT\u003e per-binding auto-free (W-03).\n- **v0.31.6.0–v0.31.6.4 — `nodrop` per-binding RAII opt-out (W-04)** — new\n  keyword threaded through lexer/parser/AST (NODROP-DEC-001/002/006/012),\n  IR-generator opt-out guard for all five RAII regions\n  (`wild` / `wildx` / `Handle\u003cT\u003e` / `HandleArena` / JIT;\n  NODROP-DEC-003/004/005), outer-only rule\n  (`identity(nodrop f())` does **not** opt out; NODROP-DEC-011),\n  borrow-checker mirror keeping `ARIA-014` honest on `nodrop wildx`\n  bindings (NODROP-DEC-009/010), and **ARIA-051 retired** — the\n  redundant `HandleArena.free(h)` on a RAII-managed binding is now a\n  hard `ARIA-022` error whose hint recommends `nodrop` as the\n  per-binding escape hatch (NODROP-DEC-013). Five-slice cycle\n  (v0.31.6.0–v0.31.6.4); see\n  [AUDIT_v0.31.6.x.md](META/NITPICK/ROADMAP/0.31/AUDIT_v0.31.6.x.md).\n- **v0.31.7.0–v0.31.7.6 — NLL Drop / last-use early-drop (W-07)** — new\n  function attribute `#[nll_drop]` retimes auto-emitted RAII drops from\n  lexical scope end to the **last-use point** of each enrolled binding\n  (NLL-DEC-001/003), computed by a real backward CFG\n  `LivenessAnalysis` (NLL-DEC-003/005/006; promoted from the previously\n  empty-mapped Gemini-Report stub at 5 back-edge merge sites,\n  `--dump-liveness` debug flag added in v0.31.7.2). Per-binding\n  `#[lexical_drop]` override keeps scope-end timing inside an\n  otherwise NLL-enabled function (NLL-DEC-002). IR-gen emission via\n  `DropEntry::consumed_` flag + last-use walker for all five RAII\n  regions (NLL-DEC-004/007/009/014; `pass v;` move skips the drop;\n  unwind walker skips consumed entries; borrow lifetimes tighten under\n  the attribute). Redundant-attribute diagnostic `ARIA-052` for\n  `#[nll_drop]` on a function with no RAII bindings\n  (NLL-DEC-013). K semantics ships parse-and-ignore (NLL-DEC-012):\n  3 new `FuncDecl` productions + 8 `loadFuncs` reduction rules + 3\n  core tests (152–154) cover the new grammar path; rationale is that\n  K already models drops at lexical scope end as the conservative\n  upper bound and RAII destructors are idempotent at-most-once within\n  a function. Seven-slice cycle (v0.31.7.0–v0.31.7.6); see\n  [AUDIT_v0.31.7.x.md](META/NITPICK/ROADMAP/0.31/AUDIT_v0.31.7.x.md).\n- **v0.31.8.0–v0.31.8.5 — trait-method `$$i` return signatures + `from \u003cident\u003e` source-binding (W-13)** —\n  trait methods may now return `$$i`/`$$m` borrows; the borrow checker\n  resolves the return-borrow source parameter via a layered rule: an\n  explicit `from \u003cident\u003e` clause wins (TRAIT-RET-DEC-003); otherwise a\n  single borrow param is used (TRAIT-RET-DEC-002); otherwise a `self`\n  borrow is preferred on trait methods, falling back to the first borrow\n  param (TRAIT-RET-DEC-005). Dynamic dispatch through `dyn Trait` of a\n  return-borrow method is rejected (TRAIT-RET-DEC-007 / **ARIA-053**)\n  because the receiver identity needed to tie the returned borrow's\n  lifetime is erased by the fat-pointer dispatch. The `from` clause\n  validates against the parameter list: an unknown name is\n  **ARIA-055** (TRAIT-RET-DEC-008), a non-borrow named source stays\n  **ARIA-023**, and a `from` clause on a by-value return is\n  **ARIA-054** (warn, TRAIT-RET-DEC-009). K core grows three\n  runtime value-flow locks (tests 155–157) for the\n  single-source / explicit-`from r` / `self`-default paths;\n  full $$i return-type modeling in K is deferred. Six-slice cycle\n  (v0.31.8.0–v0.31.8.5); see\n  [AUDIT_v0.31.8.x.md](META/NITPICK/ROADMAP/0.31/AUDIT_v0.31.8.x.md).\n- **v0.31.9.0–v0.31.9.6 — Phase-3 carryover residue (W-15)** —\n  three deferred Phase-3 surfaces folded back in: real `is unknown`\n  taint fold over a per-binding `mayBeUnknown` flag\n  (PHASE3-DEC-002/003/004), callee return-taint summary inferred from\n  `pass unknown` in body (PHASE3-DEC-005/006), reject assignment to a\n  `fixed` struct field while still allowing `$m` borrows of the\n  *other* fields (PHASE3-DEC-007/008/009 / **ARIA-056**), and the\n  declared return-flow marker `T?unknown` opting a callee into\n  the same `mayBeUnknown` propagation as a body-discovered `pass\n  unknown` (PHASE3-DEC-011/012/013). K core grows four runtime\n  tests (158–161) for the `unknown` surface keyword and\n  Int↔Unknown comparison rules (PHASE3-DEC-010); the two\n  compile-time-rejection items have no runtime artefact and are\n  intentionally not modeled in K. Six-slice cycle\n  (v0.31.9.0–v0.31.9.6); see\n  [AUDIT_v0.31.9.x.md](META/NITPICK/ROADMAP/0.31/AUDIT_v0.31.9.x.md).\n- **v0.31.10.x–v0.31.14.x — extension cadence (deferred-item sweep)** —\n  five sub-cycles closing the remaining v0.31.x deferral queue:\n  v0.31.10.x (transitive ARIA-032 cross-module summary visibility),\n  v0.31.11.x (RAII / Drop on `JitFn` + JIT region polish),\n  v0.31.12.x (per-PID temp paths + cross-module sidecar interop),\n  v0.31.13.x (release-valve hint + test polish, RUN_SERIAL\n  stabilization), v0.31.14.x (closure capture for non-primitive\n  types — struct, `string`, `int64` handle, `$$i`/`$$m` borrows;\n  ARIA-060 `INVALID_CLOSURE_CAPTURE`, K core tests 170+171,\n  `guide/functions/closures.md`). See\n  [AUDIT_v0.31.10.x.md](META/NITPICK/ROADMAP/0.31/AUDIT_v0.31.10.x.md)\n  through\n  [AUDIT_v0.31.14.x.md](META/NITPICK/ROADMAP/0.31/AUDIT_v0.31.14.x.md).\n- **v0.31.15.0–v0.31.15.4 — MACRO-007 complex code-gen macros\n  (final deferred item from v0.23.x)** — macros can now emit\n  multiple top-level declarations from one invocation, splice\n  fields into a `struct`, splice methods into an `impl`, and\n  carry template-literal interpolations with **hygiene**.\n  Splice surface is bare `name!(args);` with a three-token\n  parser lookahead (no new `%splice` keywords, MACRO2-DEC-001..003).\n  `MacroDeclStmt` and `MacroInvocationExpr` carry a\n  `definingScope_` pointer; `hygieneRewriteTemplateLiterals`\n  resolves each `\u0026{ident}` interpolation in **both** the\n  defining scope and the caller scope, and emits\n  **ARIA-061 `MACRO_HYGIENE_VIOLATION`** (warning) when the two\n  scopes yield different `Symbol*` values\n  (MACRO2-DEC-004/005/007). `#caller(NAME)` is the documented\n  opt-out — parses as `UnaryExpr(#, Call(\"caller\", [Ident]))`\n  and rewrites to a bare `\u0026{NAME}` in the caller scope\n  (MACRO2-DEC-006). One latent `cloneAST` `TEMPLATE_LITERAL`\n  recursion bug discovered and fixed under this work\n  (MACRO2-DEC-008). K core grows two runtime value-flow locks\n  (tests 172 + 173) for the post-expansion shape; the expander,\n  hygiene walker, and ARIA-061 emit are C++-only per\n  MACRO2-DEC-010. Tests 170+171 from v0.31.14.x — which failed\n  K's `kparse` stage at original write-up — were also fixed in\n  this slice (literal suffixes stripped, lambda invocation\n  switched to `raw k(arg)` matching tests 121/124).\n  Five-slice cycle (v0.31.15.0–v0.31.15.4); see\n  [AUDIT_v0.31.15.x.md](META/NITPICK/ROADMAP/0.31/AUDIT_v0.31.15.x.md).\n- **v0.31.16.0–v0.31.16.3 — K-Framework catch-up (final\n  extension sub-cycle)** — K-only cycle draining the\n  formal-model backlog so v0.32.x launches with the runtime\n  and K layers in sync. Closes **TRAIT-RET-DEC-011** (full K\n  modelling of `$$i T` as a return type, deferred from\n  v0.31.8.x): 3 new `FuncDecl` productions + 5 new\n  `loadFuncs` parse-and-elide rules into the existing\n  pass/fail/stmt-pass tables in `aria.k`, ratified by K core\n  tests 174 (zero-arg) and 175 (one-arg pass-through). Adds\n  K proof #12 **`nll-drop-idempotence-proofs.k`** (4 claims,\n  depth-4 stress) ratifying NLL-DEC-003 at the K level —\n  drops are idempotent on `\u003cenv\u003e` / `\u003cstore\u003e` /\n  `\u003cpinned-hosts\u003e`, so the NLL last-use point and the\n  conservative lexical-scope-end point produce identical K\n  configurations (KMOD-DEC-004). Slice 16.1 also rectified\n  a plan-doc drift: `pin-address-stable-proofs.k` was\n  claimed deferred but had actually landed at v0.27.4 /\n  v0.31.3.10 (KMOD-DEC-001); the cycle audit codifies\n  **R-3** as a binding process change — every future K\n  claim must cite `git log --oneline -- \u003cpath\u003e` evidence.\n  No runtime, codegen, type-checker, or borrow-checker\n  changes; no new ARIA codes; no new bug fixtures. K\n  `\u003cliveness\u003e` cell promotion remains rejected\n  (KMOD-DEC-005, reaffirms NLL-DEC-007). Four-slice cycle\n  (v0.31.16.0–v0.31.16.3); see\n  [AUDIT_v0.31.16.x.md](META/NITPICK/ROADMAP/0.31/AUDIT_v0.31.16.x.md).\n\nSee [AUDIT_v0.31.x.md](AUDIT_v0.31.x.md) and\n[RELEASE_v0.31.x.md](RELEASE_v0.31.x.md) for the full cycle audit.\n\n---\n\n## Previous cycles\n\n**Stable release: v0.25.7 — Borrow Checker Hardening complete (8-release cycle)**\n\nThe v0.25.x cycle delivered a comprehensive hardening of the borrow checker:\nstatement-visitor coverage, `defer` and early-exit handling, multi-dim and\nnested array borrow paths, 3+-level struct field paths and `ptr-\u003efield`,\ninter-procedural parameter intent and return-borrow lifetime, two-phase\nborrows, `$$m self` in trait impls, closure-capture borrow tracking,\nmulti-await polish, secondary-span diagnostics, plus K-semantics test coverage\nfor multilevel field disjointness, two-phase release, and async release.\nAll 14 tracked BORROW items are resolved.\n\n**Current validation snapshot:** CTest **53/53** passing (release build,\nK semantics enabled); `k_semantics_core` **145/145** under K Framework v7.1.320;\n`k_semantics_proofs` **10/10** proof modules; **204** regression bug tests\n(bug001 – bug204, including 105 borrow-specific); **103 packages**;\n**72 stdlib modules**.\n\n**v0.25.x highlights (released this cycle):**\n- **v0.25.0** — Statement-visitor audit + coverage matrix; `FAIL`/`TILL`\n  dispatch (BORROW-001).\n- **v0.25.1** — `defer` body borrow tracking + early-exit leak audit\n  (BORROW-002, BORROW-003).\n- **v0.25.2** — Multi-dim and nested array borrow paths (BORROW-004).\n- **v0.25.3** — 3+-level struct field paths and `ptr-\u003efield` paths\n  (BORROW-005, BORROW-006).\n- **v0.25.4** — Inter-procedural parameter intent and return-borrow\n  lifetime (BORROW-007, BORROW-008).\n- **v0.25.5** — Two-phase borrows and `$$m self` in trait impls\n  (BORROW-009, BORROW-010).\n- **v0.25.6** — Closure-capture borrow tracking, multi-await `$$m` polish,\n  ARIA-023 / ARIA-026 secondary spans (BORROW-011/012/013).\n- **v0.25.7** — K semantics test coverage (3 new core tests),\n  9-chapter [`guide/borrow/`](https://github.com/alternative-intelligence-cp/nitpick-docs/tree/main/guide/borrow)\n  cookbook, and the [v0.25.7 audit](AUDIT_v0.25.7.md) closing the cycle.\n\n**Stable release: v0.24.7 — Comptime / CTFE system complete (8-release cycle)**\n\nThe v0.24.x cycle delivered the full compile-time evaluation subsystem: pure\nexpression folding, comptime blocks, `comptime func:` declarations with\nmemoization, type intrinsics (`@sizeof`, `@alignof`, `@offsetof`, `@len`,\n`@typeInfo`, `@fieldType`), `T: type` generic parameters, `limit\u003cRules\u003e`\nshort-circuit at comptime, `assert_static`, struct field reflection, and a\nformal K-Framework model of the comptime layer. All 14 tracked COMPTIME items\nare resolved.\n\n**Current validation snapshot:** CTest **46/46** passing (release build,\nK semantics enabled); `k_semantics_core` **142/142** under K Framework v7.1.320;\n`k_semantics_proofs` **10/10** proof modules; **172** regression bug tests\n(bug001 – bug172); **103 packages**; **72 stdlib modules**.\n\n**v0.24.x highlights (released this cycle):**\n- **v0.24.0–v0.24.2** — Comptime triage, `comptime(expr)` const folding,\n  `comptime { ... }` blocks with mutable locals, `comptime func:` with\n  memoization, `@sizeof`/`@alignof`/`@offsetof`/`@len` intrinsics, comptime\n  string operations.\n- **v0.24.3–v0.24.4** — Macro × comptime cooperation, `assert_static`,\n  comptime call-chain diagnostics, recursion budget enforcement.\n- **v0.24.5** — Comptime generics: `T: type` parameters and type-level dispatch.\n- **v0.24.6** — `limit\u003cRules\u003e` short-circuit at comptime; explicit\n  enforcement of comptime limitations (no I/O, GC, extern, async, threading,\n  pinning, RNG, time).\n- **v0.24.7** — Struct field reflection (`@typeInfo(T).fields.\u003cname\u003e`,\n  `@fieldType(T, \"f\")`), K semantics for the comptime layer (3 new K core\n  tests, `\u003ccomptime-env\u003e` configuration cell), 9-chapter\n  [`guide/comptime/`](https://github.com/alternative-intelligence-cp/nitpick-docs/tree/main/guide/comptime)\n  documentation, and the [v0.24.7 audit](AUDIT_v0.24.7.md) closing the cycle.\n\n**Catching up — major series since the last GitHub release on `main` (v0.17.5):**\n- **v0.18.x** — K Framework executable semantics seed; KLEE symbolic execution;\n  Juliet CWE corpus; bounded safety hardening.\n- **v0.19.x** — Array, struct, and borrow-checker polish; loop-body borrow\n  checking; K semantics through 127 core tests.\n- **v0.20.x** — Diagnostics \u0026 warning system polish, preprocessor hardening,\n  Display trait, closure lifetimes, `optional\u003cT\u003e`.\n- **v0.21.x** — Audit-driven follow-ups: cfg compilation, `derive(Display)`,\n  async borrow checking, `Rules`/Z3 disjointness, ICE quality, AArch64 JIT\n  diagnostics, K `tbb8`/`tbb16`/`tbb64`, K `async`/`await`.\n- **v0.22.x** — Port-driven polish (CHIP-8, jsmn, Brainfuck): `get_argc`/\n  `get_argv` builtins, `break`/`continue`, pick on integers, bitwise ops,\n  string escape sequences, reserved-keyword diagnostics.\n- **v0.23.x** — Full macro system: hygiene, recursion + depth guard, variadic\n  macros, statement-position invocations, built-in macros (`assert!`, `todo!`,\n  `unreachable!`, `cfg!`), `--expand-macros` flag, K semantics for macros.\n- **v0.24.x** — Comptime / CTFE system.\n- **v0.25.x** — Borrow Checker Hardening (this release).\n\n**Previous series highlights:**\n- **v0.17.x** — Installers, packaging, and distribution: enhanced `install.sh`,\n    Debian `.deb` builder, RPM builder, `aria-pkg` remote fetch from GitHub.\n- **v0.16.x** — Full compiler/runtime/tooling audit: 0 TODO/FIXME/HACK in C++\n    source, 72 stdlib modules audited, 33 examples tested, 171-page manual\n    regenerated, **800K+ fuzz tests** with 0 crashes.\n- **v0.15.x** — Self-hosting: 12 compiler/tool modules ported to Aria (lexer, parser, type checker, borrow checker, safety checker, exhaustiveness, const evaluator, module resolver, doc generator, package manager, project config), final census\n- **v0.14.x** — SMT solver expansion: contract proofs, range inference, data race analysis, fast-paths, documentation\n- **v0.13.x** — Traits, enums, generics, deferred language features, @ function pointers, 234-page PDF manual, final audit (959 tests, 17h+ fuzzing)\n- **v0.12.x** — Networking \u0026 middleware: HTTP, DNS, socket, server, URL, cookie, CORS, body-parser, session, static, rate-limit, FTP, SMTP, WebSocket, display, input, LRU, glob, retry\n- **v0.11.x** — Threading \u0026 concurrency: thread pool, atomics, lock-free structures, channels, mutex/rwlock/barrier, arena/pool/slab allocators, shared memory, IPC, signal handling, AIFS, AriaX kernel mods\n- **v0.7.x** — JIT: 45+ x86-64 instructions, linear scan register allocator, peephole optimizer, WildX security, 0.66x native C -O2\n- **v0.5.x** — Z3 SMT formal verification: contracts, overflow proofs, concurrency/memory safety verification\n- **v0.3.x–v0.4.x** — Ecosystem packages, Z3 Phase 1–3, AriaX kernel mods\n\n---\n\n## Compiler Toolchain\n\n| Tool | Status | Description |\n|---|---|---|\n| `npkc` | ✅ Stable | Full compiler, LLVM 20 backend (`ariac` is a compat alias) |\n| `aria-ls` | ✅ Stable | Language Server — hover, goto-definition, completion, documentSymbol, references, signatureHelp |\n| `npkpkg` | ✅ Stable | Package manager — install, search, pack, 103 packages verified |\n| `aria-doc` | ✅ Stable | Documentation generator — 435 unique HTML pages from ecosystem |\n| `aria-mcp` | ✅ Stable | MCP server — compile, safety audit, docs search, format, specialist model |\n| `aria-safety` | ✅ Stable | Static safety auditor — 11 checks including UNSAFE, EXTERN, CAST, TODO; `--json` output |\n| Z3 Verifier | ✅ Stable | SMT-based formal verification — contracts, overflow, concurrency, memory safety, `prove`/`assert_static`, `--smt-opt` |\n| K semantics | ✅ v0.18.x seed | Executable formal semantics seed — `kompile`/`krun` core oracle, `kprove` proof hook, CTest integration, 109/109 core tests, 10/10 proof modules |\n| `aria-dap` | ✅ Stable | Debug Adapter Protocol — LLDB 20 backend, conditional breakpoints, logpoints |\n| `npkbld` | ✅ Stable | Build system — project manifest, dependency resolution, test runner |\n| `install.sh` | ✅ Stable | One-command build + install with prerequisite checking |\n| Fuzzer V2 | ✅ Active | 27 generators, 100% compile rate, zero unresolved crashes |\n| Specialist model | ✅ V6+SMT | Qwen 7B LoRA, v6 corpus + v7 SMT verification examples |\n| Linux packages | ✅ Stable | Debian `.deb` and RPM builders, plus source/install-script paths |\n| AriaX Linux | 🔧 In progress | Custom distro with full toolchain |\n| `aria_packages` | ✅ Active | 103 packages, all passing |\n| PDF Manual | ✅ v1.1 | [171-page programming manual](https://github.com/alternative-intelligence-cp/aria-docs/releases/tag/v0.16.11) — specs, guide, safety walkthrough, reference |\n\n---\n\n## Language Features\n\n### Stable\n- **All primitive types** — int1/2/4/8/16/32/64/128/256/512/1024/2048/4096, uint1/2/4/8/16/32/64/128/256/512/1024/2048/4096, flt32/64/128/256/512, bool, string\n- **TBB Types (tbb8/16/32/64)** — Symmetric signed integers with overflow sentinel (-128/ERR)\n- **TFP TYPES (tfp16/32)** — Twisted Floating Point\n- **any** — type erased pointer, equivalent to void* in C\n- **Balanced Ternary/Nonary Literals \u0026 Runtime** — `0t[01T]+` and `0n[01234ABCD]+` syntax, full trit/tryte/nit/nyte arithmetic\n- **Quantum Types (Q3/Q9/Q21)** — Gradient thinking: two-hypothesis superposition with confidence levels and crystallization thresholds\n- **Generic Functions and Structs** — Monomorphization with type inference\n- **Result Types** — `pass`/`fail` with `?` propagation and `!` unwrap, `Result\u003cT\u003e` signatures, `_?`/`_!` shorthand operators\n- **`fail()` from user functions** — Result-style: `fail(err)` produces `Result{error:err, is_error:true}`, complement to `pass(val)`\n- **Layered Safety** — `?!` (checked), `!!!` (unchecked), `unknown`/`ok()`, `failsafe`\n- **Async/Await** — LLVM coroutine-based with promise mechanism for error propagation through async boundaries\n- **All loop forms** — `while`, `for(;;)` (C-style), `for (i in a..b)` (range), `loop`, `till`, `when/then/end`\n- **Control flow** — `if/else`, `pick` (exhaustive match), `break`, `continue`, `fall`\n- **Module system** — `use`, `mod`, `pub`, `extern`\n- **Closures** — First-class functions with capture\n- **Z3 Formal Verification** — SMT-based compile-time proofs: contracts (`requires`/`ensures`), overflow elimination, data race detection, deadlock detection, use-after-free proofs, `prove`/`assert_static` builtins, `--smt-opt` optimizations, configurable `--smt-timeout`\n- **Borrow checker** — Compile-time memory safety analysis\n- **Arrays in structs** — Fixed-size scalar and struct array fields with nested member access\n- **SIMD types** — Vector arithmetic via LLVM intrinsics\n- **Atomic types** — Lock-free concurrent primitives\n- **Dimensional algebra** — Unit-typed arithmetic\n- **NIL/void separation** — NIL is Aria's unit type (wrapped in `Result\u003cnil\u003e`), void restricted to extern blocks, bridge via pointer erasure\n- **NIL/NULL separation** — NIL for no value, NULL for no reference\n- **Operators** — Full suite including `+` (string concatenation), `@` (address), `#` (pin), `-\u003e` (arrow), `..`/`...` (ranges)\n- **Template literals** — `` `\u0026{variable}` `` string interpolation\n- **Six-stream I/O** — stdin/stdout/stderr/stddbg/stddati/stddato with runtime initialization, graceful fallback, `stdin_read_all()` and `stdin_read_line()` builtins\n- **sys() syscall interface** — Three-tier direct Linux syscall invocation (`sys`/`sys!!`/`sys!!!`) with compile-time safety whitelist, Result\u003cint64\u003e wrapping, and TOS escalation integration\n- **Traits** — Definition, implementation, UFCS on primitive types, `dyn Trait` vtable dispatch, trait bounds on generics\n- **Optional types** — `T?` with `??` nil-coalescing, `?.` safe navigation; working for primitives and custom types\n- **Async channels \u0026 actors** — Buffered/unbuffered/oneshot channels, actor spawn/send/stop, fan-out/fan-in/pipeline patterns\n- **Standard library** — string_convert, string (manipulation), string_builder, print_utils, wave/wavemech, complex, dbug, quantum, atomic, io (file streams), math (transcendentals), linalg (linear algebra), collections (Vec, Map, Set, Graph), json, toml, binary, net (TCP sockets)\n\n### In Progress / Specified\n- **AriaX Linux** — Custom distro with full toolchain pre-installed\n- **Specialist model V7** — Next training corpus covering v0.16.x additions\n\n---\n\n## `aria-packages` Library Ecosystem\n\nAll packages live in the separate [`aria-packages`](https://github.com/alternative-intelligence-cp/aria-packages) repository. 103 packages total, organized into utility, graphics/game, server, database, and AI/ML tiers. Each package has a `src/` module, a `tests/` file with assertions, and where FFI is needed, a C `shim/`.\n\n**Package tiers:**\n\n| Package | Description |\n|---------|-------------|\n| aria-actor | Extended actor patterns (pool, router, supervisor) |\n| aria-aifs | AI filesystem utilities (POSIX ops + metadata tagging) |\n| aria-args | Command-line argument parsing |\n| aria-ascii | ASCII character classification and conversion |\n| aria-audio | Software synthesis, MIDI note table, ALSA backend |\n| aria-base64 | Base64 encoding/decoding |\n| aria-bench | Benchmarking |\n| aria-bigdecimal | Arbitrary precision decimal arithmetic |\n| aria-bits | Bit test/set/clear/flip, nibble extraction, popcount |\n| aria-body-parser | HTTP body parsing middleware (JSON, URL-encoded, multipart) |\n| aria-buf | Byte/word packing for uint64 buffers |\n| aria-channel | High-level channel patterns (fan-out, fan-in, pipeline) |\n| aria-clamp | min, max, clamp, abs, sign for int64/uint64 |\n| aria-cli | Enhanced CLI parsing with subcommands |\n| aria-color | RGBA packing/unpacking and pixel transforms |\n| aria-compress | Data compression (LZ4/zstd via FFI) |\n| aria-console | 16-bit memory-mapped address space + 60fps frame scheduler |\n| aria-conv | Saturating narrowing and float/int conversion |\n| aria-cookie | Cookie parsing and Set-Cookie builder |\n| aria-cors | CORS middleware with configurable origins |\n| aria-crypto | Cryptographic primitives (SHA-256, AES, HMAC via FFI) |\n| aria-csv | CSV parsing and generation |\n| aria-cuda | CUDA FFI: device management, memory ops, kernel launch, cuBLAS |\n| aria-datetime | Date/time formatting and arithmetic |\n| aria-decision-t | Decision tree classifier (entropy, information gain) |\n| aria-diff | Text diffing |\n| aria-display | ANSI/termios terminal rendering (virtual console) |\n| aria-dns | DNS resolution |\n| aria-editor | Terminal-mode text editor with search |\n| aria-endian | Big/little-endian byte-swap for 16/32/64-bit |\n| aria-entangled | Quantum-inspired entangled variable pairs |\n| aria-env | Environment variable access and process info |\n| aria-fixed | Q32.32 fixed-point arithmetic on uint64 |\n| aria-freq | Frequency/period/baud integer arithmetic |\n| aria-fs | File system utilities (stat, mkdir, readdir, copy) |\n| aria-ftp | FTP client session management |\n| aria-gml | GML compatibility layer: 40+ functions, xorshift32 RNG |\n| aria-gradient-field | 3D gradient field computation |\n| aria-gtk4 | GTK4 desktop GUI: widget registry, events, non-blocking UI |\n| aria-hash | FNV-1a and djb2 string hashing |\n| aria-hex | Hexadecimal encoding/decoding |\n| aria-http | HTTP client (GET/POST requests) |\n| aria-ini | INI config file parsing |\n| aria-input | Raw keyboard input with SNES-style button mapping |\n| aria-jamba | Hybrid Transformer + Mamba + Mixture of Experts model |\n| aria-jit | WildX JIT helpers |\n| aria-json | JSON encoding for basic types |\n| aria-libc | Standard C library wrappers |\n| aria-log | Structured logging with severity levels |\n| aria-looping | Iterative refinement model with convergence stopping |\n| aria-mamba | Mamba selective state space model with SiLU gating |\n| aria-map | Map data structure |\n| aria-math | Trig, exp, log, rounding via C libm |\n| aria-matrix | Matrix operations |\n| aria-mime | MIME type detection and mapping |\n| aria-mock | Test mocking framework |\n| aria-msgpack | MessagePack binary serialization |\n| aria-mux | Bit-select, field insert/extract, mask ops, blend |\n| aria-mysql | MySQL/MariaDB client via libmysqlclient |\n| aria-opengl | OpenGL 3.3 Core via GLAD + SDL2 |\n| aria-path | Path manipulation | \n| aria-postgres | PostgreSQL client via libpq (parameterized, LISTEN/NOTIFY) |\n| aria-pqueue | Priority queue (min-heap) |\n| aria-qt6 | Qt6 Widgets GUI toolkit bindings |\n| aria-queue | Queue data structure |\n| aria-rand | xorshift64 pseudo-random number generator |\n| aria-rate-limit | Token bucket rate limiting middleware |\n| aria-raylib | raylib v6.0 bindings: window, drawing, shapes, text, input, audio, gamepad |\n| aria-redis | Redis client via hiredis (strings, lists, hashes, sets) |\n| aria-regex | Regular expression matching |\n| aria-resource-mem | RAII-style resource lifecycle management |\n| aria-ringbuf | Ring buffer (circular buffer) |\n| aria-router | Express-style router: path params, middleware, wildcards |\n| aria-rules-common | Commonly used Rules\u003cT\u003e declarations |\n| aria-sdl2 | SDL2 multimedia bindings: window, renderer, drawing, events |\n| aria-sdl3 | SDL3 bindings |\n| aria-semver | Semantic versioning: parse, compare, satisfy |\n| aria-server | HTTP/1.1 server: listen, accept, parse, respond |\n| aria-session | In-memory session management with crypto IDs |\n| aria-smtp | SMTP email composition |\n| aria-socket | Socket abstraction layer |\n| aria-sort | Various sorting algorithms |\n| aria-sqlite | SQLite3 embedded database client (parameterized queries) |\n| aria-static | Static file serving with MIME detection and path traversal protection |\n| aria-stats | Statistics functions |\n| aria-str | String utilities (pad, trim, repeat, contains, split) |\n| aria-template | String template rendering with variable substitution |\n| aria-tensor | Dense tensor library: creation, arithmetic, matmul, activations, GPU interop |\n| aria-test | Test framework with assertion helpers |\n| aria-tetris | Full Tetris clone: sound effects, gamepad, high score |\n| aria-toml | TOML configuration file parsing |\n| aria-transformer | Transformer encoder: multi-head attention, causal masking |\n| aria-uacp | Universal AI Communication Protocol: binary framing, 8 message types |\n| aria-url | URL parsing, encoding, query string manipulation |\n| aria-uuid | UUID v4 generation and formatting |\n| aria-vec | 2D/3D float64 vector math (dot, cross, length) |\n| aria-websocket | WebSocket client/server (RFC 6455) |\n| aria-webkit-gtk | WebKitGTK web content bindings |\n| aria-wxwidgets | wxWidgets GUI toolkit bindings |\n| aria-xml | XML parsing and generation |\n| aria-yaml | YAML parsing and serialization |\n| aria-zigzag | Zigzag encode/decode for signed integer interleaving |\n\n---\n\n## Overview\n\nAria is a systems programming language that reimagines I/O and type systems for AI-native applications. Inspired by Nikola Tesla's vision of interconnected systems, Aria introduces **six-stream I/O** where programs communicate through stdin, stdout, stderr, stddbg, stddati, and stddato — separating human-readable, debug, and machine-readable data at the language level.\n\nThe language is being built as the primary substrate for **Nikola**, a consciousness architecture based on the Asymmetric Toroidal Phase Model (ATPM). Aria's features — balanced types, deterministic arithmetic, explicit memory lifecycle, and quantum superposition types — are not arbitrary; they are requirements of the Nikola model.\n\n### Research Foundation\n\n- **ATPM (Asymmetric Toroidal Phase Model):** DOI [10.5281/zenodo.18158226](https://doi.org/10.5281/zenodo.18158226)\n- **ATPM Extended:** DOI [10.5281/zenodo.18168992](https://doi.org/10.5281/zenodo.18168992)\n- **Ego-Mediated Behavior Study:** DOI [10.5281/zenodo.18159274](https://doi.org/10.5281/zenodo.18159274)\n- **Nikola Model Architecture:** DOI [10.5281/zenodo.18159162](https://doi.org/10.5281/zenodo.18159162)\n- **Design rationale** (non-physicist version): [docs/ATPM_DESIGN_RATIONALE.md](docs/ATPM_DESIGN_RATIONALE.md)\n\n---\n\n## Key Language Features\n\n### Layered Safety System\n\nAria's safety philosophy: make dangerous operations **explicit**, provide multiple layers for error handling, and never let a program crash silently.\n\n**Layer 1: Failsafe** — Every Aria program has a `failsafe` that catches unhandled errors:\n```aria\nfunc:failsafe = int32(tbb32:err) {\n    // Log, cleanup, graceful shutdown\n    exit(1);\n};\n```\n\n**Layer 2: Result Types** — Explicit error propagation with concise syntax:\n```aria\nfunc:divide = int32(int32:a, int32:b) {\n    if (b == 0i32) { fail(-1i32); }\n    pass(a / b);\n};\n\nint32:result = divide(10i32, 2i32) ? 0i32;  // Unwrap with default\n```\n\n**Layer 3: Unknown/Ok Pattern** — Explicit null safety without null types:\n```aria\nint32:maybe_valid = unknown;\nif (some_condition) {\n    maybe_valid = 42i32;\n    ok(maybe_valid);  // Mark as valid\n}\n// ok() returns the value itself — use wherever the value is needed\nint32:safe_val = ok(maybe_valid);\n```\n\n**Layer 4: TBB Overflow Detection** — Symmetric integers with error sentinels:\n```aria\ntbb8:x = 120tbb8;\ntbb8:y = 10tbb8;\ntbb8:result = x + y;     // Overflow: result = ERR (-128)\ntbb8:err = -128tbb8;\nif (result == err) {\n    drop(println(\"Overflow detected!\"));\n}\n```\n\n**Layer 5: Z3 SMT Formal Verification** — Compile-time mathematical proofs via Z3 solver:\n```aria\n// Design-by-Contract: requires/ensures are verified at compile time\nfunc:safe_divide = int32(int32:a, int32:b)\n    requires b != 0i32\n    ensures $ \u003e= 0i32\n{\n    pass(a / b);\n};\n\n// Integer overflow proofs: Z3 bitvector analysis proves absence of overflow\nfunc:safe_add = int32(int32:a, int32:b)\n    requires a \u003e 0i32, a \u003c 1000i32, b \u003e 0i32, b \u003c 1000i32\n{\n    pass(a + b);  // Z3 proves: no overflow possible in int32 range\n};\n```\n```bash\n# Verify contracts and overflow safety at compile time\nnpkc program.npk --verify-contracts --verify-overflow --verify-report -o program\n```\nAria uses the Z3 SMT solver to mathematically *prove* the absence of contract violations and arithmetic overflow across all possible execution paths — the same class of static formal verification used by Ada/SPARK for safety-critical aerospace and automotive systems.\n\n### For Loops — Two Forms\n\n```aria\n// C-style: precise control\nfor(int32:i = 0i32; i \u003c 10i32; i += 1i32) {\n    drop(println(int32_toString(i)));\n}\n\n// Range-based: clean iteration\nfor (i in 1..10) {          // inclusive: 1, 2, ..., 10\n    drop(println(int64_toString(i)));\n}\nfor (i in 1...10) {         // exclusive: 1, 2, ..., 9\n    drop(println(int64_toString(i)));\n}\nfor (int32:i in 0...5) {    // with explicit type annotation\n    drop(println(int32_toString(i)));\n}\n```\n\n\u003e Note: `i++` is not supported. Use `i += 1i32` or `i = i + 1i32`.\n\n### TBB Types — Symmetric Signed Integers\n\n```aria\ntbb8:x = 120tbb8;\ntbb8:y = 10tbb8;\ntbb8:result = x + y;     // Overflow: result = ERR (-128)\ntbb8:err = -128tbb8;\nif (result == err) {\n    drop(println(\"Overflow detected!\"));\n}\n\n// Sticky error propagation\ntbb8:sum = result + x;   // ERR + anything = ERR\n```\n\n### Quantum Types — Gradient Thinking\n\nQuantum types track two hypotheses simultaneously with confidence levels, crystallizing to a definite value when evidence accumulates. Three granularity levels: Q3 (ternary), Q9 (nonary), Q21 (21-state with saturation barriers).\n\n```aria\nuse \"stdlib/quantum.aria\".*;\n\n// Q3\u003cT\u003e: Simple 3-state confidence (trit: -1, 0, +1)\nQ3\u003cint32\u003e:sensor = {a: 20i32, b: 25i32, c: 0};  // Two hypotheses, unknown confidence\n\n// Both hypotheses evolve together\nQ3\u003cint32\u003e:updated = {a: sensor.a + 5i32, b: sensor.b + 5i32, c: 1};\n\n// Crystallize when confident\nint32:result = 0i32;\nif (updated.c \u003e 0) { result = updated.b; }  // Evidence favors B → 30\nif (updated.c \u003c 0) { result = updated.a; }  // Evidence favors A → 25\n\n// Q9\u003cT\u003e: 9-state confidence (nit: -4 to +4) for finer gradients\nQ9\u003cint32\u003e:decision = {a: 100i32, b: 200i32, c: -3};  // Moderately favor A\n\n// Q21\u003cT\u003e: 21-state confidence (tbb8: -10 to +10, saturation barriers at ±6)\nQ21\u003cint32\u003e:complex = {a: 42i32, b: 84i32, c: 8};  // Past barrier, crystallizable\n```\n\n### Balanced Ternary Literals (Syntax Complete)\n\n```aria\nint64:six     = 0t1T0;    // 1×9 + (-1)×3 + 0×1 = 6\nint64:neg_one = 0tT;      // -1\nint64:four    = 0n4;      // balanced nonary: 4\nint64:neg_four = 0nD;     // -4\n```\n\n---\n\n## Quick Start\n\n### One-Command Install\n\n```bash\ngit clone https://github.com/alternative-intelligence-cp/aria.git\ncd aria\n./install.sh              # build + install to /usr/local\n```\n\nThe install script checks prerequisites, builds all tools, and installs binaries, stdlib, and man pages. Options:\n\n```bash\n./install.sh --build-only          # build without system install\n./install.sh --prefix=$HOME/.local # install to custom prefix\n./install.sh --install-deps        # auto-install missing packages\n./install.sh --uninstall           # remove installed files\n```\n\n### Package Install\n\n```bash\n# Debian / Ubuntu / Mint\nsudo dpkg -i aria-lang_*_amd64.deb\n\n# Fedora / RHEL\nsudo rpm -ivh aria-lang-*.x86_64.rpm\n```\n\nBuild packages with `./packaging/build-deb.sh` or `./packaging/build-rpm.sh`.\n\nSee [INSTALL.md](INSTALL.md) for all installation methods.\n\n### Manual Build\n\n```bash\nmkdir -p build \u0026\u0026 cd build\ncmake ..\ncmake --build . -j$(nproc)\ncd ..\n```\n\n### Hello World\n\n```bash\ncat \u003e hello.npk \u003c\u003c 'EOF'\nfunc:main = int32() {\n    drop(println(\"Hello from Nitpick!\"));\n    exit(0);\n};\nfunc:failsafe = int32(tbb32:err) { exit(1); };\nEOF\n\n./build/npkc hello.npk -o hello\n./hello\n```\n\n```bash\n# Compile options\n./build/npkc program.npk -o program          # compile\n./build/npkc program.npk --emit-llvm -o out.ll  # LLVM IR\n./build/npkc program.npk -O2 -o program      # optimized\n./build/npkc program.npk --emit-wasm -o out.wasm  # WebAssembly\n```\n\n### Linking Standard Library Dependencies\n\nCertain standard library modules (like `io.npk`, `string.npk`, and `math.npk`) depend on external C shim libraries provided by the `aria-libc` (or `nitpick-libc`) package. When compiling a program that imports these modules natively with `npkc`, you must explicitly pass the linker flags for these shared objects:\n\n```bash\n# Example: Compiling word_count.npk which uses io.npk and string.npk\n./build/npkc word_count.npk -o word_count -L/path/to/aria-libc/shim -laria_libc_io -laria_libc_string -laria_libc_mem\n```\n\n*Note: If you use the `test-all.sh` script or the `aria-pkg` manager, these dependencies are automatically parsed from `nitpick-package.toml` and linked for you.*\n\n**Prerequisites:** LLVM 20.1+, CMake 3.20+, C++17 compiler, Python 3.8+, Linux/macOS/WSL2\n\n---\n\n## Documentation\n\n📚 **[aria-docs](https://github.com/alternative-intelligence-cp/aria-docs)** — Package reference, language guides, and tutorials (separate repo).\n\n📖 **[Aria Programming Manual v1.1 (PDF)](https://github.com/alternative-intelligence-cp/aria-docs/releases/tag/v0.16.11)** — 171-page offline manual: specs cheat sheet, full programming guide, safety walkthrough, and reference appendix.\n\n**Quick links in aria-docs:**\n- `guide/` — Full programming guide (12 sections)\n- `reference/` — Language reference (20+ documents)\n- `safety-walkthrough/` — Safety system walkthrough\n- `packages/` — API reference for all packages\n\n**Man pages:** Install with `./install.sh` — then `man aria-control-flow-for`, `man aria-types-int32`, etc.  \n**Language spec:** [`.internal/aria_specs.txt`](.internal/aria_specs.txt)  \n**Compiler architecture:** [`docs/ARCHITECTURE.md`](docs/ARCHITECTURE.md)\n\n---\n\n## Project Structure\n\n```\naria/\n├── .github/                  # CI/CD and GitHub templates\n│   ├── workflows/           # GitHub Actions (build + test)\n│   └── ISSUE_TEMPLATE/      # Bug report, feature request, crash report\n├── src/                      # Compiler source\n│   ├── frontend/            # Lexer, parser, AST, semantic analysis\n│   ├── backend/             # LLVM IR generation\n│   └── runtime/             # Runtime support (GC, strings, async, streams)\n├── include/                  # Headers\n├── stdlib/                   # Standard library (.aria files)\n├── tests/                    # Test suite\n│   ├── regression/          # Regression tests\n│   ├── fuzz/                # Fuzzer V2 and corpus\n│   ├── gpu/                 # GPU/CUDA tests\n│   └── misc/                # Exploratory/scratch tests and archived test results\n├── examples/                 # Example programs\n├── docs/                     # Design docs and architecture\n├── k-semantics/              # K Framework executable semantics and core tests\n├── scripts/                  # Build and maintenance scripts\n├── tools/                    # Development tooling (specialist model, semantic_db)\n├── benchmarks/               # Performance benchmarks\n├── runtime/                  # Runtime C source\n├── vendor/                   # Vendored dependencies\n├── third_party/              # Third-party components\n├── debian/                   # Debian packaging\n├── .internal/                # Internal: spec, session notes, status docs\n├── build/                    # Build artifacts (gitignored)\n├── CMakeLists.txt\n├── README.md\n├── SAFETY.md\n├── CHANGELOG.md\n├── CONTRIBUTING.md\n└── LICENSE.md\n```\n\n**Related repositories:**\n- [`aria-packages`](https://github.com/alternative-intelligence-cp/aria-packages) — 103 library packages\n- [`aria-docs`](https://github.com/alternative-intelligence-cp/aria-docs) — reference docs, guides, and [171-page PDF manual](https://github.com/alternative-intelligence-cp/aria-docs/releases/tag/v0.16.11)\n- [`ariax`](https://github.com/alternative-intelligence-cp/ariax) — POSIX tools and AX Linux distro\n- [`aria-lang`](https://github.com/alternative-intelligence-cp/aria-lang) — VS Code extension\n- [`aria-make`](https://github.com/alternative-intelligence-cp/aria-make) — build system\n\n---\n\n## Testing\n\n```bash\n# Run regression tests\n./tests/regression/run_regression.sh\n\n# Run the full test suite\n./scripts/run_comprehensive_tests.sh\n\n# Run K executable-semantics core tests (requires K Framework)\n./k-semantics/run_k_tests.sh --require-k\n\n# Run fuzzer\ncd tests/fuzz \u0026\u0026 python3 fullstack_fuzzer.py\n\n# Single test\n./build/npkc tests/some_feature.npk -o /tmp/t \u0026\u0026 /tmp/t\n```\n\nTest results are archived in `test_results/` for regression tracking. The fuzzer archives crashes in `tests/fuzz/crashes_archive/`.\n\n---\n\n## Development Roadmap\n\n### v0.1.0 — Released\n\n- ✅ Full compiler toolchain (ariac, aria-lsp, aria-dap, aria-doc, aria-pkg)\n- ✅ Layered safety system (?!, !!!, unknown/ok(), failsafe)\n- ✅ Quantum types (superpose/collapse)\n- ✅ TBB types with sticky overflow sentinels\n- ✅ Full generic system (functions + structs, monomorphization)\n- ✅ Both for loop forms (C-style and range-based)\n- ✅ Borrow checker (compile-time memory analysis)\n- ✅ SIMD and atomic types\n- ✅ Dimensional algebra\n- ✅ 678 compiler tests, Fuzzer V2, Valgrind-clean runtime\n- ✅ 27 `aria_packages` libraries with 543+ assertions (all passing)\n- ✅ All 27 compiler bugs found, fixed, verified\n- ✅ Full documentation (web, man pages, programming guide, Getting Started)\n\n### v0.2.0 — Released\n\n- ✅ **Self-hosting compiler frontend** — Lexer, parser, type checker, borrow checker, safety checker, exhaustiveness checker, and const evaluator ported to Aria (220 tests across 5 modules)\n- ✅ **stdlib expansion** — 9 modules (io, math, linalg, collections, string, json, toml, binary, net) with 290+ passing tests\n- ✅ **7 additional codegen bugs fixed** — Inline return comparison, string concatenation, pass() unwrapping, pointer reassignment, NIL comparison, cross-module pointer corruption\n- ✅ **Improved compiler diagnostics** — \"Did you mean?\" suggestions, accurate source locations for all type errors\n- ✅ **License changed to Apache 2.0**\n- ✅ **Language specialist model** V3 complete (71% pattern match), V4 in progress\n\n### v0.2.2 — Released\n\n- ✅ **GUI toolkit wrappers** — Idiomatic Aria bindings for raylib (20 tests), SDL2 (19 tests), GTK4 (20 tests) via C shim pattern\n- ✅ **9 utility libraries** — aria-test, aria-csv, aria-log, aria-base64, aria-datetime, aria-regex, aria-fs, aria-socket, aria-http (166 tests, all passing)\n- ✅ **Tooling improvements** — aria-ls (documentSymbol, references, signatureHelp), aria-mcp (format tool, resources), aria_make (test command), aria-dap (conditional breakpoints, logpoints), aria-safety (4 new checks, --json)\n- ✅ **Debian packaging** — `aria_0.2.2-1_amd64.deb` (17 MB), tested on Linux Mint 22.3\n- ✅ **Repository reorganization** — Monorepo split into 10 repos under `alternative-intelligence-cp` org\n- ✅ **V5 specialist corpus** — 2,688 examples covering all v0.2.2 additions\n- ✅ **Extended fuzzing** — 48-hour adversarial campaign, zero unresolved crashes\n\n### v0.2.3 — Released\n\n- ✅ **Database client libraries** — 4 packages: aria-sqlite (34 assertions), aria-postgres (40 assertions), aria-mysql (44 assertions), aria-redis (53 assertions)\n- ✅ **Parameterized queries by default** — All SQL drivers use parameter binding; SQL injection tests pass on all 3 SQL drivers\n- ✅ **Full CRUD + transactions** — Insert, select, update, delete, begin/commit/rollback across all drivers\n- ✅ **PostgreSQL LISTEN/NOTIFY** — Async notification support\n- ✅ **Database guide** — `aria-packages/DATABASE_GUIDE.md` with prerequisites, patterns, and API reference\n- ✅ **V6 specialist model** — Updated corpus covering database additions\n\n### v0.2.4 — Released\n\n- ✅ **Async/await error propagation** — Promise-based `Result\u003cT\u003e` through coroutine boundaries, fixed dual await paths, proper memory management, Valgrind-clean\n- ✅ **`fail()` from user functions** — Result-style mechanism: `fail(err)` is complement to `pass(val)`, no more sentinel workarounds\n- ✅ **Arrays in structs fixed** — Nested member access (`cloud.pts[0].x`) for read and write, Aria element type registration\n- ✅ **Balanced ternary/nonary runtime** — Full trit/tryte arithmetic (add, sub, mul, div, mod), 15/15 tests\n- ✅ **NIL ↔ void bridge** — NIL = Aria unit type, void = C ABI only, pointer erasure bridge\n- ✅ **Code quality pass** — 44 deprecated LLVM API migrations, all warnings fixed, zero Aria-source warnings\n- ✅ **Traits \u0026 borrow semantics RFC** — Design doc for monomorphized traits + `$$i`/`$$m` borrow qualifiers\n- ✅ **6 regression tests** — Dedicated regression suite covering critical bug fixes\n\n### v0.2.1.1 — Released\n\n- ✅ **aria-dap debugger** — Full DAP server with LLDB 20 backend. Breakpoints, stepping, stack traces, variable inspection.\n- ✅ **`-g` flag** — DWARF debug info generation with proper source paths, variable locations, and subprogram entries.\n- ✅ **VS Code debugging** — Debug configuration provider, auto-compile, launch.json snippets, `aria.debugger.path` setting.\n- ✅ **O0 for debug** — Automatically disables LLVM optimization when `-g` is set to preserve variable visibility.\n\n### v0.2.1 — Released\n\n- ✅ **aria-pkg fixed** — Registry loading, metadata parsing, tarball extraction; added search/pack/directory-install. 27/27 packages verified.\n- ✅ **aria-doc fixed** — Parser rewritten for Aria colon syntax. Generates 435 unique HTML pages, zero `unknown.html` collisions.\n- ✅ **aria-ls wired** — AST-based hover (type signatures + builtin descriptions), goto-definition, completion (37 keywords + 15 types + file symbols).\n- ✅ **install.sh** — One-command build and install with prerequisite checking, `--prefix`, `--uninstall`. Tested on clean Linux Mint 22.3 VM.\n- ✅ **aria-mcp verified** — compile, docs, safety, ask endpoints all functional.\n- ✅ **VS Code extension** — v0.2.1 with updated bundled aria-ls binary.\n- ✅ **Benchmark suite** — 3 benchmarks (primes, collatz, gcd) in Aria and C with runner script. Aria matches or beats gcc -O2 on 2/3 benchmarks.\n- ✅ **Clean-machine build verified** — CMake and install.sh fixes for fresh Linux installs.\n\n### v0.2.5 — Released\n\n- ✅ **CI/CD pipeline** — GitHub Actions: build, test, .deb packaging on push/PR to main/dev\n- ✅ **GitHub templates** — Bug report, feature request, compiler crash issue templates; PR template with checklist\n- ✅ **CONTRIBUTING.md** — Contributor guide with prerequisites, build instructions, code style\n- ✅ **Compiler architecture manual** — 695-line technical document covering full pipeline, AST, type system, IR generation, runtime, FFI, memory model\n- ✅ **Man pages** — groff man pages for ariac(1), aria-ls(1), aria-pkg(1), aria-doc(1), aria-dap(1)\n- ✅ **Documentation fixes** — Tested 24 code examples, fixed 7 doc bugs, documented 2 compiler bugs\n- ✅ **Specialist model evaluation** — Comprehensive evaluation of all model versions, strategy documented\n\n### v0.2.6 — Released\n\n- ✅ **`--shared` flag** — Compile Aria source directly to `.so` shared libraries with C ABI export\n- ✅ **Cross-language bindings** — Aria → C, Python (ctypes), Rust (FFI), Go (cgo); documented in `docs/CROSS_LANGUAGE_BINDINGS.md`\n- ✅ **GUI/game packages** — aria-raylib (v6.0), aria-sdl2, aria-gtk4, OpenGL bindings (aria-opengl via GLAD)\n- ✅ **12 new library packages** — aria-test, aria-csv, aria-log, aria-base64, aria-datetime, aria-regex, aria-fs, aria-socket, aria-http, and infrastructure packages\n- ✅ **aria-doc improvements** — Full HTML generation pipeline, 435+ unique pages\n\n### v0.2.7 — Released\n\n- ✅ **Six-stream I/O runtime** — All 6 streams (stdin/stdout/stderr/stddbg/stddati/stddato) initialized with graceful fallback\n- ✅ **`stdin_read_all()` / `stdin_read_line()` builtins** — Proper AriaString wrapping, pipes and non-seekable streams supported\n- ✅ **Argument access runtime** — `aria_get_argc()`, `aria_arg(index)` builtins; compiler auto-generates `main(i32, ptr)` signature\n- ✅ **26 POSIX tools** — cat, head, tail, wc, tee, cut, sort, uniq, tr, grep, find, diff, echo, yes, true, false, env, sleep, basename, dirname, seq, nl, fold, paste, expand, unexpand (in `ariax` repo)\n- ✅ **Pipeline support** — All tools read from stdin when no file argument given\n- ✅ **String comparison fix** — `_=expr` discard syntax, `sleep_ms` builtin\n\n### v0.2.39 — Released\n\n- ✅ **Enums** — `enum:Name = { VARIANT1, VARIANT2 = 42 };` with auto-numbering (0, or last+1), explicit values, mixed\n- ✅ **EnumType** — Proper type identity in type system (not just int64 constants)\n- ✅ **Enum-typed variables** — `Color:my_color = Color.RED;`\n- ✅ **Enum comparison** — `==` and `!=` between enum values\n- ✅ **Enum exhaustiveness** — `pick` statements can check coverage of all variants\n- ✅ **Parser pre-pass** — Correctly distinguishes `Enum.VARIANT` from UFCS static calls\n\n### v0.2.38 — Released\n\n- ✅ **AI-Native Filesystem** — aria-aifs package: POSIX file ops + AI metadata tagging via C shim\n- ✅ **Shim layer** — 16 C functions for create/read/write/delete/stat/list + tag/untag/find_by_tag\n\n### v0.2.37 — Released\n\n- ✅ **Channels** — `Channel.create(cap)`, `send()`, `recv()`, `try_send()`, `try_recv()`, `select2()`, `close()`\n- ✅ **Channel modes** — Buffered, unbuffered (rendezvous), oneshot (auto-close)\n- ✅ **Actors** — `actor_spawn(handler)`, `actor_send()`, `actor_stop()`, `actor_destroy()`\n- ✅ **Actor patterns** — Reply channels, mailbox access, lifecycle management\n- ✅ **aria-channel package** — FanOut, FanIn, Pipeline high-level patterns\n- ✅ **aria-actor package** — Actor pool, router, supervisor patterns\n\n### v0.2.36 — Released\n\n- ✅ **dyn Trait** — Dynamic dispatch via vtables, object-safe trait checking\n- ✅ **Vtable generation** — Runtime polymorphism for trait objects\n\n### v0.2.35 — Released\n\n- ✅ **Borrow semantics** — `$$i` (immutable) and `$$m` (mutable) borrow qualifiers\n- ✅ **Compile-time safety** — N immutable OR 1 mutable borrow enforced\n- ✅ **`any` type** — Universal type erased container\n- ✅ **Pinning improvements** — `#` operator integration with borrow checker\n\n### v0.2.34 — Released\n\n- ✅ **Type: system** — Composable types with `struct:internal`, `struct:interface`, `struct:type`, methods\n- ✅ **Trait bounds on generics** — `func\u003cT: Addable\u003e:name = ...` constrained generics\n- ✅ **instance\u003cT\u003e** — Constructor syntax: `instance\u003cCounter\u003e(args)` → `Counter_create(args)`\n\n### v0.2.33 — Released\n\n- ✅ **Generic stdlib** — Generic containers, iterators, optional monads\n- ✅ **Foundation packages** — aria-container, aria-iter, aria-optional\n\n### v0.2.30-v0.2.32 — Released\n\n- ✅ **Incremental improvements** — Parser fixes, type system refinements, test coverage expansion\n\n### v0.2.29 — Released\n\n- ✅ **String `+` operator** — `\"hello \" + \"world\"` concatenation, chaining, type checker + codegen\n- ✅ **`wildx` parser fix** — Qualifier missing from 7 parser locations; added `isWildx` to AST nodes\n- ✅ **6 new packages** — aria-jit (8/8), aria-bench (4/4), aria-path (10/10), aria-sort (8/8), aria-queue (7/7), aria-map (8/8)\n- ✅ **Legacy stdlib removed** — Entire `lib/_legacy/std/` deleted (42 files, 22 modules); all covered by packages/builtins\n- ✅ **80 ecosystem packages** — 45 new tests, all passing\n\n### v0.2.28 — Released\n\n- ✅ **fix256** — 256-bit deterministic fixed-point: arithmetic, comparisons, conversions; SysV ABI fixed for 32-byte structs\n- ✅ **frac32** — Fraction type with function-call API (from_parts, add/sub/mul/div)\n- ✅ **SIMD builtins audit** — Deferred test audit, 841 tests total, 838 passing (99%)\n- ✅ **Dimensional type stubs** — Type infrastructure for unit-typed arithmetic\n\n### v0.2.27 — Released\n\n- ✅ **Complex number stdlib** — Generic complex API (new, add, sub, mul, conjugate) with int32/int64/flt64\n- ✅ **Compound generic type inference** — GenericResolver extracts type args from monomorphized struct names\n\n### v0.2.26 — Released\n\n- ✅ **Module resolution fixes** — Restored `std` → `stdlib` symlink, created `stdlib/mem.aria`\n- ✅ **4 tests promoted** — 830/833 passing (99%)\n\n### v0.2.25 — Released\n\n- ✅ **SIMD builtins fixed** — Critical bug: LLVM float comparisons (fcmp vs icmp) for vector types, fixed in 10 locations\n- ✅ **7 tests unblocked** — simd_sum, simd_broadcast, simd_product, element access, reductions\n\n### v0.2.23 — Released\n\n- ✅ **Trait system** — Definition parsing, implementation, UFCS on primitive types\n- ✅ **Parser infinite loop fix** — Trait blocks no longer hang the compiler\n- ✅ **815/818 passing** (99%)\n\n### v0.2.22 — Released\n\n- ✅ **Optional types** — `T?` syntax, `NIL` literal, `??` nil-coalescing, `?.` safe navigation, `?` unwrap-with-default\n- ✅ **ABI** — Tagged struct `{i1 hasValue, T value}` for optionals\n\n### v0.2.19 — Released\n\n- ✅ **Generic monomorphization fix** — `substituteTypeNode()` for recursive type parameter substitution\n- ✅ **Compound types** — GenericType, ArrayType, PointerType substitution in generics\n\n### v0.2.18 — Released\n\n- ✅ **Test-side fixes** — 19 tests promoted to main suite, no compiler changes\n- ✅ **Discovery** — `instance\u003cT\u003e()` and `Type.Member` desugaring already work\n\n### v0.2.16 — Released\n\n- ✅ **Spec compliance pass** — 122 test fixes (void→NIL, failsafe, return→pass)\n- ✅ **5 compiler bugs fixed** — Plus 47 TODOs audited\n- ✅ **Partial feature completion** — cast `=\u003e`, pipelines `|\u003e`, safe nav `?.`, pub use, invariants\n\n### v0.2.15 — Released\n\n- ✅ **Ecosystem \u0026 distribution polish** — Tooling updates, LSP grammar +49 keywords, package registry synced (55→74)\n- ✅ **Website and repo presentation** — Version strings, code examples, install scripts refreshed\n\n### v0.2.14 — Released\n\n- ✅ **Documentation \u0026 quality** — Comprehensive doc review, extended fuzzing, full test suite hardening, code audit across all repos\n\n### v0.2.13 — Released\n\n- ✅ **WebAssembly compilation target** — `ariac --emit-wasm -o program.wasm` compiles Aria to WASI-compatible WebAssembly\n- ✅ **WASM runtime** — `libaria_runtime_wasm.a`: strings, I/O, math, allocators, maps (~850 LOC)\n- ✅ **LLVM WebAssembly backend** — `emit_wasm_object()`, wasm-ld linking, WASI entry point handling\n- ✅ **Compatibility checker** — Warns about unsupported features (threading, async, fork/exec) at compile time\n- ✅ **Compiler-rt builtins** — `__multi3` (128-bit multiply) for int64 arithmetic on wasm32\n- ✅ **WASM test suite** — 4/4 passing: hello world, strings, arithmetic, functions/recursion\n\n### v0.2.12 — Released\n\n- ✅ **Preprocessor macros** — `macro:NAME(params) { body }`, `%*` variadic, `#%N` stringification, `##` token pasting\n- ✅ **Comptime evaluation** — `comptime { }` blocks, evaluated at compile time\n- ✅ **Magic constants** — `__FILE__`, `__LINE__`, `__FUNC__`, `__COUNTER__`\n- ✅ **Inline hints** — `inline` and `noinline` function attributes\n- ✅ **Borrow checker improvements** — Better analysis of conditional paths and reassignment\n- ✅ **Compiler diagnostics** — Improved error messages for macro expansion and comptime errors\n\n### v0.2.11 — Released\n\n- ✅ **Thread pool** — `ThreadPool.create()`, `ThreadPool.submit()`, `ThreadPool.wait_idle()`, `ThreadPool.shutdown()`\n- ✅ **Atomics** — `AtomicInt32`, `AtomicInt64`, `AtomicBool` with all memory orderings\n- ✅ **Lock-free data structures** — `LFQueue` (MPMC), `LFStack` (Treiber), `RingBuf` (SPSC)\n- ✅ **Channels** — `Channel.create()`, `Channel.send()`, `Channel.recv()` for inter-thread communication\n- ✅ **Mutex/RWLock/Barrier/CondVar** — Full synchronization primitives\n- ✅ **OS components** — Arena, pool, slab allocators; shared memory; IPC; signal handling; process management\n- ✅ **AI-native filesystem (AIFS)** — FUSE-based filesystem for AI workloads\n- ✅ **AriaX kernel mods** — Hexstream FD 3-5 patches\n\n### v0.2.10 — Released\n\n- ✅ **aria-transformer** — Full Transformer encoder with multi-head attention, causal masking, attention visualization (10/10 tests)\n- ✅ **aria-mamba** — Mamba SSM: selective scan, 1D convolution, SiLU gating, layer norm (10/10 tests)\n- ✅ **aria-jamba** — Hybrid Transformer + Mamba + MoE: interleaved layers, top-k expert gating (10/10 tests)\n- ✅ **aria-looping** — Iterative refinement model: shared weights, iteration embeddings, convergence stopping (10/10 tests)\n- ✅ **aria-tensor** — Dense tensor library: 47 operations, GPU interop (12/12 tests)\n- ✅ **aria-cuda** — CUDA FFI: device mgmt, memory ops, kernel launch, cuBLAS GEMM (10/10 tests)\n- ✅ **aria-uacp** — Universal AI Communication Protocol: binary framing, 8 message types (12/12 tests)\n- ✅ **Self-improving training loop** — Automated specialist: generate → compile → filter → retrain\n\n### v0.2.9 — Released\n\n- ✅ **HTTP server** — aria-server: listen, accept, parse, respond with headers and status codes\n- ✅ **Express-style router** — aria-router: path params, middleware chains, wildcards, method dispatch (21 tests)\n- ✅ **6 server middleware libraries** — body-parser (28), cors (18), cookie (23), session (23), rate-limit (14), static (22) — 154+ tests total\n- ✅ **REST API demo** — demo_api.aria: 5 endpoints with HTML, JSON, path params, POST handling\n- ✅ **Borrow checker fix** — False positive on void externs with `_close`/`_free` in name\n- ✅ **FFI string return ABI fix** — AriaString struct returns from extern functions\n\n### v0.2.8 — Released\n\n- ✅ **Repo reorganization** — `aria_ecosystem/` split into `aria-packages`, `aria-docs`, and `ariax` repos\n- ✅ **Gamepad input API** — Full button/axis constants in aria-raylib; gamepad support in aria-tetris\n- ✅ **Procedural audio synthesis** — `rl_gen_beep()`: square/triangle/sawtooth/sine tones, no audio files needed\n- ✅ **aria-tetris** — 928-line Tetris clone with sound, gamepad, high score, line-clear flash animation\n- ✅ **aria-gml** — GML compatibility layer: 40+ functions, xorshift32 RNG, persistent draw state\n- ✅ **aria-opengl** — OpenGL 3.3 Core bindings via GLAD + SDL2\n- ✅ **aria-editor** — Terminal-mode text editor (file open/edit/save/search)\n- ✅ **16 new packages** — 59 total in aria-packages\n- ✅ **FFI codegen fixes** — Explicit float literals, auto-wrap `char*` → `AriaString` for extern string returns\n- ✅ **GML → Native tutorial** — Full walkthrough in aria-docs\n\n### v0.3.0 — Released\n\n- ✅ **`--static` flag** — Compile static executables with all dependencies linked\n- ✅ **Fuzzer rewrite** — 27 generators, 100% compile rate, zero unresolved crashes\n- ✅ **BUG-001 through BUG-004 fixes** — Module resolution for FFI packages, linker flag ordering, failsafe/main/exit contract enforcement\n- ✅ **92 ecosystem packages** — 5 new: rules-common, ini, hex, ringbuf, pqueue\n\n### v0.3.1 — Released\n\n- ✅ **Version bump** — Package ecosystem expansion and stability improvements\n\n### v0.3.2 — Released\n\n- ✅ **101 ecosystem packages** — aria-stats, aria-matrix, aria-mock, aria-bigdecimal + SDL3, wxWidgets, WebKitGTK wrappers\n- ✅ **GUI framework expansion** — SDL3, wxWidgets, WebKitGTK bindings via C shim pattern\n\n### v0.3.3 — Released\n\n- ✅ **Safety showcase \u0026 tooling polish** — CI/CD badges, comprehensive documentation fixes (695+)\n- ✅ **Dead code removal** — 860 lines of dead code removed from compiler\n- ✅ **Debug print gating** — 118 debug prints behind `ARIA_DEBUG_CODEGEN` flag\n- ✅ **LSP version bump** — Language server updated to 0.3.3\n\n### v0.3.4 — Released\n\n- ✅ **Z3 SMT Phase 2: Design-by-Contract verification** — `requires`/`ensures` clauses verified at compile time via Z3 solver. Function preconditions and postconditions are mathematically proven across all execution paths.\n- ✅ **Z3 SMT Phase 3: Arithmetic overflow proofs** — Integer arithmetic operations verified using Z3 bitvector overflow intrinsics (`bvadd_no_overflow`, `bvsub_no_underflow`). Proves absence of overflow for bounded inputs.\n- ✅ **`--verify-contracts` flag** — Enable contract verification pass\n- ✅ **`--verify-overflow` flag** — Enable overflow verification pass\n- ✅ **`--verify-report` flag** — Emit detailed proof results (proven/unproven/skipped per function)\n- ✅ **Regression fix** — `test_nested_struct_array` updated: `pass()` → `exit()` in main\n\n### v0.4.x–v0.10.x — Released\n\n- ✅ **v0.4.x** — Z3 Phase 1 (Rules/limit), ecosystem to 103 packages\n- ✅ **v0.5.x** — Z3 Phase 2–3 (contracts, overflow, concurrency, memory verification), `prove`/`assert_static`, `--smt-opt`\n- ✅ **v0.6.x** — TFP types, compiler hardening\n- ✅ **v0.7.x** — JIT: 45+ instructions, register allocator, peephole optimizer, WildX security\n- ✅ **v0.8.x–v0.9.x** — Runtime improvements, GC tuning\n- ✅ **v0.10.x** — 8 stdlib modules ported to aria-libc, 12 pure Aria packages, tests/docs/audit\n\n### v0.11.x — Released\n\n- ✅ **Threading \u0026 concurrency** — Thread pool, atomics, lock-free structures (MPMC queue, Treiber stack, SPSC ring buffer)\n- ✅ **Synchronization** — Mutex, RWLock, Barrier, CondVar\n- ✅ **OS components** — Arena/pool/slab allocators, shared memory, IPC, signal handling, process management\n- ✅ **AI-native filesystem (AIFS)** — FUSE-based filesystem for AI workloads\n- ✅ **AriaX kernel mods** — Hexstream FD 3-5 patches\n\n### v0.12.x — Released\n\n- ✅ **Networking** — HTTP client, DNS, socket, server, URL parsing\n- ✅ **Middleware** — Cookie, CORS, body-parser, session, static file serving, rate limiting\n- ✅ **Protocols \u0026 terminal** — FTP, SMTP, WebSocket, ANSI display, raw keyboard input\n- ✅ **Utilities** — LRU cache, glob matching, retry with backoff\n\n### v0.13.x — Released\n\n- ✅ **Trait system** — Definitions, `impl` blocks, `$i`/`$m` borrows, vtable dispatch, trait bounds on generics\n- ✅ **Enum types** — Tagged unions, pattern matching, exhaustiveness checking\n- ✅ **Generic containers** — Type-parameterized structs/functions, monomorphization\n- ✅ **Deferred features** — Raw strings, pipeline operator, extended escape sequences\n- ✅ **@ function pointers** — Trampoline generation for `@func_name` references\n- ✅ **Documentation** — specs_list.txt, full reference docs, 234-page PDF manual\n- ✅ **Final audit** — 959 tests, 17h+ fuzzing (0 crashes), benchmarks, KNOWN_ISSUES/BUGS cleanup\n\n### v0.14.x — Released\n\n- ✅ **SMT solver expansion** — Contract proofs, range inference, data race analysis, fast-paths, comprehensive documentation\n\n### v0.15.x — Released\n\n- ✅ **Self-hosting foundation** — 5 compiler modules ported to Aria (lexer, parser, type checker, borrow checker, safety checker)\n- ✅ **Tier 2 self-hosting** — 4 modules ported (exhaustiveness checker, const evaluator, module resolver, visibility checker)\n- ✅ **Tier 3 tool ports** — Doc generator, package manager, project config ported to Aria\n- ✅ **Self-hosting census** — 12 total modules ported, final audit and documentation\n\n### v0.16.x — Released\n\n- ✅ **Comprehensive code review** — Full C++ compiler, runtime, and toolchain reviewed (~122,000+ lines, 130+ files)\n- ✅ **11 compiler bugs fixed** — Dead code removal, wrong-value bugs, memory/ownership fixes, ABI corrections\n- ✅ **72 TODO resolutions** — Backend codegen, type checker, analysis passes, async/runtime stubs, parser, tools\n- ✅ **Subsystem reviews** — Frontend, semantic analysis, backend, runtime, tools each reviewed independently\n- ✅ **Stdlib audit** — 72 .aria files reviewed, 13 bugs fixed\n- ✅ **Test stability** — 1,015 tests (891 positive, 124 expected-failure), AriaString ABI fix, @cast\u003c\u003e codegen, exit-in-lambda enforcement\n- ✅ **Error messages** — Contextual hints and improved diagnostics across 9 source files (37+ messages)\n\n### v0.17.x — Released\n\n- ✅ **Install script expansion** — Distro detection, dependency installation,\n    build-only/custom-prefix/uninstall modes, and post-install verification\n- ✅ **Debian packaging** — Standalone `.deb` builder with runtime dependencies\n    and bundled Aria libraries\n- ✅ **RPM packaging** — `.rpm` builder with generated spec and staged install\n    tree\n- ✅ **aria-pkg remote fetch** — `update`, `list --remote`, and remote package\n    install from the GitHub package registry\n- ✅ **Install documentation** — Source, script, package, and package-manager\n    install paths documented\n\n### v0.18.0 — Released\n\n- ✅ **K Framework executable semantics** — First formal semantics seed in\n    `k-semantics/aria.k`\n- ✅ **Core K test corpus** — 109 programs on `dev-0.18.x` covering exit, arithmetic, binding,\n    fixed values, loops, Result operations, sticky `ERR`, failsafe routing,\n    `if`/`else`, helper calls, strings/stdout, structs, `pick`/`fall`, and\n    integer `Rules` / `limit\u003cRules\u003e` checks, plus initial `stack`/`gc`/`wild`\n    memory qualifier checks, `defer { ... }` cleanup checks, `@`/`\u003c-` pointer\n    read/store-through checks, pointer-member read/store-through checks,\n    nested pointer-member path read/store-through checks,\n    `#` pin dereference/read-only checks, pin-member store-through rejection,\n    pin-derived nested path store-through rejection, pinned-host field mutation rejection,\n    direct and nested struct-field borrow path checks, local field-alias\n    writeback checks, fixed-array literal-index borrow path/writeback checks,\n    `wildx` cleanup checks, pinned-host by-value rejection, and `$$i`/`$$m`\n    borrow permission checks\n- ✅ **CTest integration** — K semantics test passes when K is installed and\n    skips cleanly when K is absent\n- ✅ **Proof-oriented `kprove` hook** — Haskell-backend proof runner integrated\n    with CTest; core, field-alias, pin read-only, pinned by-value,\n    local pointer, pointer-path, borrow-path, control/rules, arithmetic, and\n    Result claim modules are passing\n- ✅ **Final audit** — `AUDIT_v0.18.0.md` records validation, proof corpus, gaps,\n    and the post-tag v0.18.x note for the now-modeled fixed-array literal-index\n    borrow subset\n- ✅ **Compiler/K literal-index borrow paths** — v0.18.x now accepts and models\n    direct literal fixed-array element borrows, tracks indexed path conflicts,\n    rejects dynamic-index borrow initializers, and aliases `arr[0]` borrows to\n    source storage\n- ⏭️ **Next** — Nitpick rebrand repository/README transition, then future\n    compiler/K expansion tracks as needed\n\n### Long Term\n\n- 🚀 **4096-bit integer support** — Scientific notation format (e.g., `1.23e4096`) natively supported by the compiler for massive integers\n\nAria is the primary language substrate for **Nikola** — an autonomous AI system based on ATPM consciousness architecture. Features like quantum types, balanced types, and the six-stream I/O model exist because Nikola requires them. Aria stability is a hard prerequisite before Nikola development can proceed in earnest.\n\nSee the [engineering plan](https://github.com/alternative-intelligence-cp/nikola) for Nikola's implementation roadmap.\n\n---\n\n## License\n\nAria is licensed under the **Apache License, Version 2.0**. See [LICENSE.md](LICENSE.md) for the full text.\n\nPrograms compiled with Aria are yours — the runtime library includes a **Runtime Library Exception** so your compiled binaries can be distributed under any license you choose.\n\n---\n\n## Contributing\n\nSee [CONTRIBUTING.md](CONTRIBUTING.md). We welcome bug reports, test cases, documentation improvements, and discussion of language design decisions.\n\n---\n\n## Acknowledgments\n\nSee [ACKNOWLEDGMENTS.md](ACKNOWLEDGMENTS.md).\n\n---\n\n**Alternative Intelligence Liberation Platform (AILP)**  \n*Building tools for collaboration, not exploitation.*\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Falternative-intelligence-cp%2Fnitpick","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Falternative-intelligence-cp%2Fnitpick","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Falternative-intelligence-cp%2Fnitpick/lists"}