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.

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 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 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.

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.