Ori 2026.03.05.3-alpha (Nightly)

This release advances Ori's ARC optimizer with CFG simplification capabilities, lands four approved language proposals, and fixes two codegen correctness bugs.

---

Ori v2026.03.05.3-Alpha

This release strengthens the ARC optimizer with a new CFG simplification pass, corrects two codegen correctness bugs in LLVM, and formally approves four language proposals that expand Ori's surface syntax.

---

Features

• ARC Block Merge Pass — Added a post-lowering CFG simplification pass to the ARC optimizer that merges redundant basic blocks, reducing unnecessary branching in generated LLVM IR and laying groundwork for further peephole optimizations.

• Select Lowering for If/Else Diamonds — Added select-instruction lowering for trivial if/else diamonds in the ARC optimizer; simple conditional expressions now compile to a single LLVM select instruction rather than a branch-and-phi sequence, improving codegen quality for common patterns.

• Code Journeys Web UI — Added gallery, detail, and explainer pages for Code Journeys as Svelte components on the website, making compiler walk-throughs browsable without running the tool locally.

• Deterministic Code Journey Scoring — Added a threshold-based, 7-dimension scoring rubric (score.py) for Code Journeys, replacing subjective AI judgment with a reproducible numeric score across correctness, coverage, clarity, and other axes.

---

Bug Fixes

• Checked Negation Overflow in Codegen — Fixed incorrect code generation for checked integer negation that could produce wrong results or trigger overflow where none was intended.

• Closure Environment RC Leak — Fixed a reference-count leak in LLVM codegen where captured variables in closure environments were not being released correctly at closure drop, causing memory to accumulate at runtime.

• Unsafe Code Gating on ARM — Fixed a compile-time expect on an unsafe code path in lexer_core that was incorrectly reached on aarch64; the unsafe block is now gated to x86_64 only, restoring correct portability behavior.

---

Improvements

• Approved: byte-literals — The b'x' byte literal syntax is now an approved part of the Ori specification, enabling direct byte value construction without casting from integers.

• Approved: while Loops — The while <cond> { } loop form is now an approved language construct, providing a familiar iteration primitive alongside loop and iterator-based for.

• Approved: Impl-Colon Syntax — The impl: Trait syntax for trait constraints in impl blocks is now approved, aligning trait declaration style with the rest of the language's colon-based type annotation convention.

• Approved: Mutable Self — The mut self receiver in method declarations is now an approved syntax, allowing methods to explicitly declare that they mutate the receiver value.

• New Draft Proposals — Added draft proposals for byte-string-access (indexing byte strings by position), char-byte-classification (character/byte predicate functions), range-patterns (using ranges in match arms), and a Value trait (common interface for value-typed data).

---

Compiler Internals

• ARC Optimizer Submodule Split — Refactored the block merge pass into four focused per-phase submodules (compact, downgrade, merge, select), improving navigability and making each optimization step independently testable.

• Lexer Hygiene Refactor — Extracted Tag display logic into its own submodule, consolidated tokenization rules, and cleaned up error factory functions, reducing coupling and making the lexer easier to extend.

• Hygiene Review Across 8 Crates — Applied implementation hygiene review findings across 8 compiler crates, addressing dead code, inconsistent naming, and structural issues surfaced by the review process.

• Broad Documentation Sync — Synchronized spec, guide, proposals, and archived design documents to reflect the capability unification changes landed in recent releases, keeping reference material accurate.

Ori 2026.03.05.2-alpha (Nightly)

This release centers on LLVM codegen correctness — fixing two latent bugs in negation overflow and closure RC management — alongside new Code Journeys tooling and a hygiene pass across the compiler.

Bug Fixes

• Fixed checked negation overflow in LLVM codegen. Negation of integer minimum values was not being handled with overflow-safe semantics, which could produce incorrect results for edge-case inputs in AOT-compiled programs.

• Fixed closure environment RC leak in LLVM codegen. Captured variables in closure environments were not having their reference counts decremented correctly in certain code paths, causing memory to be retained longer than intended.

Features

• Added Code Journeys web UI. Gallery, detail, and explainer pages are now available as Svelte components, giving language enthusiasts a visual way to explore compiler traces and execution paths through Ori programs.

Improvements

• Added deterministic scoring rubric for Code Journeys. Replaced subjective AI judgment with a 7-dimension threshold-based scoring system (score.py), producing consistent, reproducible quality scores for compiler journey analysis.

Compiler Internals

• Implementation hygiene review across 8 crates. A structured audit of plumbing quality and file organization was applied to 8 compiler crates, addressing structural issues at phase boundaries before they accumulate.

• Removed redundant CI run on push to master. The CI pipeline was triggering duplicate runs on master pushes; the redundant job was removed to reduce CI noise and resource usage.

Ori 2026.03.05.1-alpha (Nightly)

This release tightens codegen correctness, brings a new Code Journeys feature (with both scoring infrastructure and a web UI), and continues a broad implementation hygiene pass across the compiler.

---

Ori v2026.03.05.1-alpha — Release Notes

This release focuses on LLVM codegen correctness and observability, introducing deterministic Code Journey scoring, a new web gallery for exploring compiler traces, and two targeted codegen bug fixes alongside a broad hygiene review across eight compiler crates.

---

Features

• Deterministic Code Journey Scoring — Added score.py, a 7-dimension threshold-based scoring rubric for Code Journeys. This replaces subjective AI judgment with a reproducible, auditable scoring pipeline, making it possible to compare journeys consistently over time and across compiler versions.

• Code Journeys Web UI — Added gallery and detail-view pages to the website using Svelte components, giving developers a browsable interface for exploring annotated compiler traces. Code Journeys are now a first-class navigable artifact rather than raw output files.

• EH Personality Implementation — Implemented an exception-handling personality function in C covering both Itanium (Linux/macOS) and SEH (Windows) ABIs, with test frame assembly for x86_64 and aarch64. This lays the groundwork for stack unwinding and structured panic recovery in AOT-compiled programs.

• LLVM Codegen Refactoring — Extracted ir_builder into focused submodules and expanded derive codegen to cover all six derivable traits. Improved the arc_emitter and function compiler internals. This restructuring makes the codegen layer easier to audit, extend, and test in isolation.

• Expanded AOT Integration Tests — Added AOT integration test suites covering ARC, derived trait implementations, for-loops, higher-order functions, operator semantics, and panic handlers. These tests validate end-to-end LLVM codegen behavior across a much wider surface area than before.

• Timeline Minimap Component — Added a TimelineMinimap Svelte component to the website's roadmap plan pages, improving navigation across long roadmap documents.

---

Bug Fixes

• Checked Negation Overflow in Codegen — Fixed a codegen bug where integer negation could overflow without triggering the checked arithmetic path. Previously, -(Int.min) could silently produce an incorrect result; it now correctly panics at runtime.

• Closure Environment RC Leak — Fixed a reference-count leak in closure environments during LLVM codegen. Captured variables in closures were not being released correctly in all code paths, causing memory to be held past the closure's lifetime.

• Windows Build Fix (Cell Import) — Gated a Cell import in ori_rt behind a #[cfg(not(target_env = "msvc"))] flag. The unconditional import caused compilation failures on Windows/MSVC targets.

• test-all.sh LCFail Count Regression — Fixed a greedy sed regex that was incorrectly parsing LCFail counts in the test runner output, causing false pass/fail tallies when multiple failures were present on a line.

---

Compiler Internals

• Hygiene Review Across 8 Crates — Completed an implementation hygiene pass touching eight compiler crates. Addressed dead code, unclear naming, duplicated logic, and structural issues surfaced during the codegen overhaul. No behavioral changes — purely surface cleanliness to keep the codebase maintainable as it grows.

• Code Journeys Consolidation — Reduced the set of tracked code journeys from 19 to 12 by merging overlapping entries and removing completed ones. The remaining journeys represent active, unresolved compiler behavior worth tracing.

• Codegen Purity Plan — Added a codegen-purity plan document capturing the architectural goal of making LLVM codegen a pure, side-effect-free transformation from IR to LLVM values. This tracks the path toward fully deterministic, testable codegen.

Ori 2026.03.04.1-alpha (Nightly)

---

v2026.03.04.1-alpha — Exception Handling, Codegen Overhaul, and Critical Match Fix

This release delivers a sweeping LLVM codegen overhaul with full exception handling support across all major platforms, alongside a critical silent miscompilation fix in match on Option<T> that restores 114 previously-failing spec tests.

---

Features

• Windows SEH Exception Handling — Implemented Structured Exception Handling for Windows in C, fully removing the dependency on Rust's panic runtime for JIT recovery. This brings Windows to parity with POSIX platforms for exception-based control flow in the AOT path.

• Itanium + SEH EH Personality in C — Added a complete EH personality implementation in C covering both Itanium (Linux/macOS) and SEH (Windows) ABIs, with test frame assembly for x86_64 and aarch64. The compiler can now emit and unwind structured exception frames across all tier-1 targets.

• Expanded AOT Integration Tests — Added AOT integration test suites covering ARC, derives, for-loops, higher-order functions, operators, and panic handlers. These test the full stack from Ori source through LLVM IR to native execution.

---

Bug Fixes

• Option<T> Match Tag Inversion (Silent Miscompilation) — Fixed a critical miscompilation where match on Option<T> silently swapped Some and None arms in both the AOT and eval paths. The root cause was a tag ordering inconsistency: resolve_variant_index() in the decision tree used None=0, Some=1 while construction emitted Some=0, None=1. Fixed across three files in ori_arc (decision tree flatten and emit) and ori_eval (decision tree walker). Resolves 114 previously-failing spec tests, bringing the suite to 4143 passing, 0 failing.

• macOS ARM64 AOT Linker Hang — Fixed an infinite retry loop in ori_llvm's linker invocation that caused AOT compilation to hang indefinitely on macOS ARM64. The linker is now given a bounded number of retry attempts before surfacing an error.

• Windows MSVC _setjmp FFI Stack Corruption — Fixed stack corruption in the JIT recovery path on Windows MSVC caused by incorrect _setjmp FFI linkage. The calling convention and frame layout now match what the MSVC runtime expects.

• -fno-exceptions Replaced with -funwind-tables — Replaced -fno-exceptions with -funwind-tables in the runtime build.rs. The previous flag suppressed unwind table generation needed by the new EH personality, causing silent failures during stack unwinding.

• Auto-Release Unicode Escape Error — Fixed a SyntaxError in the CI auto-release workflow triggered when commit messages containing \u sequences were shell-interpolated into Python string literals and misread as unicode escapes. The workflow now reads the commit log and PR bodies from temporary files at Python runtime.

• LCFail Count Parsing Regression in test-all.sh — Fixed a greedy sed regex that incorrectly parsed the LCFail (LC failure) count from test output, causing false pass/fail reporting in the test harness.

• Skip Sentinel Detection in Test Runner — Fixed skip sentinel detection to use grep -qx for exact-line matching, preventing partial matches from incorrectly marking tests as skipped.

---

Improvements

• list_ensure_capacity Runtime Test Stability — Added the missing lock_rc call in the list_ensure_capacity runtime tests, eliminating a race condition that caused intermittent failures on macOS ARM64.

• Pre-commit Hook Format Enforcement — Added fmt --check to the pre-commit hook and fixed lib.rs formatting. Formatting violations are now caught before commit rather than during CI.

---

Compiler Internals

• ir_builder Submodule Extraction — Refactored the LLVM codegen layer by extracting ir_builder into focused submodules. The monolithic codegen file is now split by responsibility, improving navigability and reducing the risk of regressions when modifying one codegen path.

• Derive Codegen Expanded to All 6 Traits — Extended the derive codegen implementation to cover all six derivable traits. Previously only a subset were handled in the AOT path; all are now fully code-generated through LLVM.

• arc_emitter and Function Compiler Improvements — Improved the ARC emitter and function compiler in the LLVM backend for correctness and clarity. Changes align the emitters more closely with the ARC IR semantics.

• Code Journey Consolidation (19 → 12) — Consolidated the compiler code journey documentation from 19 entries to 12 by merging redundant journeys and removing completed items. This keeps the journey set actionable and representative of the current architecture.

• Codegen Purity Plan Added — Added a new plan (codegen-purity) to track the ongoing work of making the codegen layer free of side-effectful, non-deterministic, and order-dependent logic — a prerequisite for reliable incremental compilation.

Ori 2026.03.03.4-alpha (Nightly)

Ori v2026.03.03.4-Alpha Release Notes

This release closes a critical silent miscompilation in Option pattern matching, upgrades the LLVM backend to version 21, and delivers Unicode escape support, cross-platform AOT improvements, and a completed value-semantics optimization plan — bringing the total passing spec test count to 4,143 with zero failures.

---

Features

• Unicode escape sequences in string and character literals — Added \u{...} escape syntax to the lexer, enabling Unicode code points to be written directly in string literals, character literals, and template strings. Compile-time validation catches malformed or out-of-range escapes before they reach codegen.

• LLVM 21 backend — Upgraded from LLVM 17 to LLVM 21, bringing access to the latest optimizer passes and IR improvements. The upgrade includes Windows SEH exception handling via catch trampolines, an ori_try_call ABI wrapper, and updated personality functions for correct unwind behavior on Windows targets.

• Windows MSVC AOT support — The AOT linker driver now discovers link.exe dynamically on Windows MSVC toolchains, unblocking native compilation on Windows without manual configuration.

---

Bug Fixes

• Fixed silent Option<T> match miscompilation — A tag-index inversion in the decision tree caused match on Option<T> to silently swap the Some and None arms in both AOT and interpreter paths. The root cause was a disagreement between resolve_variant_index() (which assumed None=0, Some=1) and the construction path (which uses Some=0, None=1). Fixed across ori_arc (decision tree flatten and emit) and ori_eval (decision tree walker). This single fix restored 114 previously-failing spec tests.

• Fixed macOS ARM64 AOT hang — An infinite retry loop in the ori_llvm linker driver caused AOT compilation to hang indefinitely on macOS ARM64. The loop now terminates correctly on linker failure.

• Fixed CI auto-release Python unicode escape crash — Commit messages containing \u sequences caused a SyntaxError when shell-interpolated into Python heredoc string literals in the release workflow. The fix reads the commit log and PR bodies from /tmp files at Python runtime, avoiding shell interpolation entirely.

• Fixed list_ensure_capacity runtime test flakiness — Added a missing lock_rc call in the list_ensure_capacity runtime tests, which was causing intermittent failures under concurrent RC-touching test runs.

---

Improvements

• Compile-time Duration and Size overflow validation — The lexer now validates Duration and Size literal values at compile time, rejecting overflows with a diagnostic rather than silently wrapping or truncating at runtime.

• Cross-platform AOT CI coverage — The CI cross-platform job now runs the full AOT test suite instead of a reduced smoke test, giving earlier and more complete signal on regressions across platforms.

• ARM/aarch64 c_char portability — Corrected C string pointer types in ori_rt to use std::ffi::c_char throughout, replacing hardcoded i8. On aarch64, c_char is u8, making the previous code unsound; the fix ensures correct behavior on both x86-64 and ARM targets.

• Valgrind script directory support — valgrind-aot.sh now accepts a directory as input, running Valgrind memory checks over all .ori files in the directory rather than requiring individual file invocations.

• Improved compile-fail diagnostic messages — Refined error output for compile-fail test cases to be more actionable.

• Value semantics optimization plan completed — All 9 sections of the COW (copy-on-write) value semantics plan are done: 16/16 Valgrind-clean scenarios, COW benchmarks baselined, and 11,887 tests passing under the full optimization pipeline.

---

Compiler Internals

• Rust toolchain pinned to 1.93.1 — All CI workflows now pin to Rust 1.93.1 for reproducible builds. A two-step function pointer cast was added in ori_llvm to satisfy the stricter cast rules introduced in this toolchain version.

• 500-line file limit enforced via submodule extraction — Several files that had grown beyond the 500-line limit were refactored into submodules, keeping the codebase navigable and consistent with project coding guidelines.

Ori 2026.03.03.1-alpha (Nightly)

Merge pull request #68 from upstat-io/dev

feat: LLVM 21 upgrade, Unicode escapes, cross-platform AOT, complete COW plan

Ori 2026.03.02.4-alpha (Nightly)

Ori v2026.03.02.4-Alpha Release Notes

This release hardens the build and runtime foundations: LLVM is now a mandatory part of every Ori build, and the map/set runtime has been rewritten from scratch for correctness and performance. Cross-platform portability also sees significant work, with Windows linker fixes and ARM compatibility corrections landing alongside new LLVM codegen capabilities.

---

Features

• List and map indexing codegen — Added LLVM code generation for list and map index expressions, bringing AOT-compiled indexing on par with the interpreter. Previously these operations were only available at eval time.

• str.split() codegen — Added LLVM codegen support for str.split(), enabling string splitting in compiled binaries without falling back to the runtime interpreter.

• collect to Set — Added the __collect_set runtime function and supporting type inference so that collection pipelines can now produce Set values directly. Also resolved a keyword conflict with union that was blocking set operations.

---

Bug Fixes

• COW slow-path exponential growth — Fixed a bug in the copy-on-write slow path that caused capacity to grow exponentially on repeated mutations. The slow path now allocates tight-fit capacity, keeping memory usage predictable.

• LLVM element store alignment — Fixed incorrect alignment used when storing elements in LLVM IR. Stores now use TypeInfo::alignment(), preventing potential misaligned-access faults on strict-alignment platforms.

• ARM/aarch64 c_char portability — Fixed the runtime to use std::ffi::c_char instead of i8 for C string pointers. On aarch64, c_char is u8, so the previous code was unsound and could produce incorrect behavior on ARM targets.

• Windows linker and UNC path issues — Fixed AOT compilation on Windows, resolving UNC path handling bugs and adding the required MSVC CRT libraries and dev environment for successful linking.

• Windows binary path resolution in tests — Fixed test infrastructure to use EXE_SUFFIX when resolving compiled binary paths on Windows, preventing test failures caused by missing .exe extensions.

• Cross-platform import path separator — Fixed a multi-file import path assertion that used a hardcoded Unix separator, causing test failures on Windows.

• Flaky ori_rt RC tests — Fixed intermittent failures in runtime reference-count tests by switching from global allocation counts to per-allocation RC checks, eliminating false positives from unrelated allocations.

• set_union benchmark correctness — Fixed the set_union benchmark to use a non-empty initial set, which was previously producing misleading (too-fast) measurements.

---

Improvements

• Rewritten map/set runtime — Replaced the previous map and set implementations with open-addressing hash tables. Open addressing improves cache locality, reduces allocation overhead, and simplifies the internal layout compared to chained structures.

• ProtocolBuiltin enum — Introduced a dedicated ProtocolBuiltin enum to represent built-in protocol dispatch targets. This replaces ad-hoc string or integer matching, making dispatch sites explicit and exhaustively checked by the compiler.

• Unified JIT/borrow ownership tracking — Refactored the compiler to share a single ownership-tracking path between JIT and borrow analysis, removing a source of drift where the two paths could silently diverge.

• Refreshed documentation and website — Rewrote the README and website landing page to lead with Ori's ARC memory model and value semantics. Added a developer blog with a launch post and blog index, and published roadmap plan pages on the website.

---

Compiler Internals

• LLVM is now a hard requirement — default = ["llvm"] is set in oric's Cargo.toml with a compile_error! guard. Attempting to build without LLVM now fails at compile time with a clear message rather than silently producing a degraded binary.

• Simplified build aliases — Removed the bl/blr/cll Cargo aliases now that cargo b always includes LLVM. ori_llvm has been added to the workspace default-members, so it participates in all workspace commands automatically.

• CI unified across platforms — Merged the previously separate LLVM CI job into the main test and clippy jobs. Cross-platform LLVM 17 installation is now handled uniformly (Linux via apt, macOS via brew, Windows via pre-built binaries), and LLVM AOT tests are excluded from the lightweight cross-platform smoke test to keep that job fast.

• Module splits for oversized files — Split several oversized compiler modules (arc_emitter and related codegen files) into focused submodules to respect the 500-line file limit. This improves navigability and reduces merge-conflict surface.

• promote_callee_args extraction — Extracted argument-promotion logic into a dedicated promote_callee_args helper, reducing duplication and making the call-lowering path easier to follow.

• Fixed 13 pre-existing Clippy violations — Addressed doc_markdown, write_with_newline, implicit_hasher, too_many_lines, manual_strip, and redundant_closure warnings across oric, bringing the workspace to a clean Clippy baseline.

• Fixed ArcFunction test and benchmark fields — Updated tests and benchmarks to include the cow_annotations and drop_hints fields added to ArcFunction, preventing silent struct-update defaults from masking missing coverage.

Ori 2026.03.02.3-alpha (Nightly)

---

Ori v2026.03.02.3-Alpha Release Notes

This release focuses on set collection support and memory model messaging — adding set as a first-class collection target in the runtime and reframing Ori's story around its ARC memory model and value semantics.

Features

• set collection in runtime — Added __collect_set as a native runtime function, enabling expression pipelines to collect into Set values directly. Paired with a fix for the union keyword conflict and updated type inference, collect-to-set now works end-to-end through the compiler pipeline.

• Blog and launch post — Added a markdown blog to the website with a dev.to launch post, a card-based index page, and navigation link. Developer-facing storytelling is now part of the project alongside the language itself.

Bug Fixes

• COW slow-path exponential growth — Fixed a bug in the evaluator's copy-on-write slow path where reallocated collections used over-estimated capacity, causing repeated COW triggers to grow memory exponentially. The slow path now allocates with tight-fit capacity.

• LLVM element store alignment — Fixed incorrect alignment used when storing elements in LLVM codegen. The store now correctly consults TypeInfo::alignment() rather than using a hard-coded or inferred value, preventing potential misaligned memory access on stricter targets.

• Flaky ori_rt RC tests — Replaced global reference-count assertions in ori_rt tests with per-allocation RC checks, eliminating a source of non-deterministic test failures caused by cross-test state leakage.

• set_union benchmark correctness — Fixed the set_union benchmark to start from a non-empty initial set, making the measurement meaningful. Removed the stale BLOCKED comment that had been left in place.

Improvements

• ARC-first project messaging — Rewrote the README and website landing page to lead with Ori's ARC memory model and value semantics, making the memory story the headline rather than a footnote. This better positions Ori relative to GC and borrow-checker alternatives.

• CI scoping fix — Fixed CI configuration to exclude the ori_llvm crate from non-LLVM jobs using the -p package shorthand, reducing unnecessary build failures on LLVM-free runners.

Compiler Internals

• Design doc sync — Performed a comprehensive sync of compiler design documentation, plans, spec pages, and Claude rules across 353 files, bringing documentation into alignment with the current implementation state.

• Removed obsolete COW benchmarks — Deleted stale COW benchmark files that no longer reflected the current allocator and COW strategy, reducing noise in the benchmarks directory.

• Website roadmap plan pages — Added structured roadmap plan pages to the website, making the development trajectory visible to contributors and followers without requiring access to internal planning documents.

Ori 2026.03.02.1-alpha (Nightly)

This release delivers a complete static uniqueness analysis pipeline for COW elimination in the ARC system — from lattice foundations through intra- and interprocedural analysis to full pipeline integration — alongside map collection method completions and deep evaluator module restructuring.

Features

• Uniqueness Lattice for Static COW Elimination — Added a foundational uniqueness lattice to the ARC pipeline, enabling the compiler to statically classify values as unique or potentially aliased. This is the groundwork for eliminating redundant copy-on-write checks at compile time rather than paying the cost at runtime.

• Intraprocedural Uniqueness Analysis — Implemented a flow-sensitive, intra-function uniqueness analysis pass that tracks ownership state through assignments, branches, and loops. Values proven unique within a function body can now bypass COW checks entirely.

• Interprocedural Uniqueness Analysis for COW Refinement — Extended uniqueness analysis across function call boundaries, allowing the compiler to propagate uniqueness guarantees into and out of callees. This significantly widens the set of COW operations that can be statically eliminated.

• Full ARC Pipeline Integration of Uniqueness Analysis — Wired intraprocedural and interprocedural uniqueness passes into the ARC pipeline proper. The analysis now runs as a first-class phase, feeding COW refinement decisions downstream.

• Drop Hints and Collection Recycling — Added drop hint annotations to the ARC IR and implemented collection recycling: when a collection is known to be dropped at a given point, its backing storage can be reused rather than deallocated and reallocated. This reduces allocator pressure for common mutation patterns.

• Map Collection Methods — Added get, insert, remove, entries, and contains to the evaluator's map type, completing the Section 06 COW parity target. Maps now have full feature parity with the COW semantics defined in the collection spec.

Bug Fixes

• Error Factory Drift in str.repeat() — Fixed a raw EvalError::new() call in the str.repeat() implementation that had diverged from the standard error factory pattern. It now correctly uses wrong_arg_type(), ensuring consistent diagnostic shape and message formatting.

Compiler Internals

• Evaluator Module Extraction — Extracted four submodules from the interpreter's bloated core files: prelude.rs (built-in bindings), operator_dispatch.rs (operator evaluation routing), stateful.rs (mutable evaluation state), and trace.rs (execution tracing). Each file now has a focused responsibility and falls within the 500-line limit.

• ARC Uniqueness Module Split — Split the uniqueness analysis into focused submodules as it grew through development, keeping intra-, interprocedural, and lattice logic in separate files. Added a COW sync test to verify the analysis and codegen agree on which operations are eliminated.

• COW Method API Unification — Unified the COW method dispatch API and optimized the uniqueness fixpoint iteration, reducing redundant work during the analysis convergence loop.

• ARC File Splits and Design Doc Restructure — Split several oversized ARC source files into submodules to comply with the 500-line limit, and restructured the ARC ISO spec layout. Rewrote both the evaluator and ARC system design documents to accurately reflect the new architecture.

Ori 2026.03.01.5-alpha (Nightly)

This release focuses on completing map COW parity and a sweeping code hygiene push — splitting oversized compiler modules to enforce the 500-line limit while delivering zero-copy list slicing as a new language feature.

Features

• Map methods complete COW parity — Added get, insert, remove, entries, and contains to the map type, bringing map operations to full parity with the COW collection model established for lists. All map mutations now follow the same copy-on-write semantics as the rest of the collection system.

• Zero-copy list slicing — Implemented list slicing via a new ListData type using offset+length encoding, supported in both the interpreter and LLVM codegen. Slices avoid heap allocation by sharing the backing array, making slice-heavy code substantially cheaper.

Bug Fixes

• Fixed error factory drift in str.repeat() — The str.repeat() built-in was constructing errors with raw EvalError::new() instead of the standard wrong_arg_type() factory, producing inconsistent diagnostic output. Corrected to use the canonical factory so error messages are uniform with the rest of the evaluator.

• Fixed website CI breakage from BUILD_NUMBER path resolution — The Hero component used import.meta.dirname to locate BUILD_NUMBER, which failed in the CI environment. Replaced with CWD-relative resolution to restore reliable builds.

Improvements

• Changelog page now surfaces GitHub release notes — The website changelog page gained a new section that pulls GitHub release notes directly, with day-level deduplication and collapsible cards for readability. Followers of the project can now track releases from the site without leaving to GitHub.

• Two-column hero with inline playground — Redesigned the landing page hero as a golden-ratio two-column grid with an embedded playground on the right, replacing the separate "See It In Action" section. The language is now demonstrated immediately on arrival rather than requiring a scroll.

• Design docs synced to implementation — Updated documentation for the ARC pipeline, pattern system, diagnostics subsystem, and LLVM backend to accurately reflect the current state of the compiler. Drift between docs and implementation was resolved across all four areas.

Compiler Internals

• Extracted four submodules from bloated interpreter files — prelude.rs, operator_dispatch.rs, stateful.rs, and trace.rs were extracted from the core interpreter to restore focused, single-responsibility modules. This is part of ongoing enforcement of the 500-line file-size limit across ori_eval.

• Split five oversized files across ori_eval and ori_rt — can_eval.rs (1387 lines) was decomposed into mod.rs, control_flow.rs, operators.rs, and function_exp.rs; method_dispatch/mod.rs, methods/collections.rs, and list/cow.rs received similar treatment. Keeping files under 500 lines improves reviewability and reduces merge-conflict surface.

• Auto-release build counter now derived from git history — The bump-build.sh script was updated to compute the daily build counter by counting commits in git history rather than relying on a mutable state file. This makes the build number deterministic and reproducible from any checkout.