# Glagol Release Notes ## Release Maturity Policy Historical `exp-*` releases listed here are experimental maturity milestones. `1.0.0-beta` is the first real general-purpose beta release. The pushed tag `v2.0.0-beta.1` is historical. It remains an experimental integration/readiness release, not the first real beta. ## Unreleased Next scoped Glagol work is expected to continue after the `1.0.0-beta.9` reservation update. No unreleased compiler scope is committed here yet. ## 1.0.0-beta.9 Release label: `1.0.0-beta.9` Release date: 2026-05-22 Release state: compiler generic and collection reservation update ### Summary Glagol `1.0.0-beta.9` reserves generic-shaped collection and stdlib syntax with explicit diagnostics instead of letting future-looking forms degrade into unknown-name or generic type errors. - Reject generic function declarations such as `(fn id (type_params T) ...)` with `UnsupportedGenericFunction`. - Reject parameterized aliases such as `(type VecOf (type_params T) ...)` with `UnsupportedGenericTypeAlias`. - Reject generic type-parameter use in concrete type positions, map types, set types, and future generic stdlib calls with focused diagnostic codes. - Mirror the rejection in `glagol fmt` and promotion-gate inventory. - Keep runtime, backend, ABI, and current concrete collection behavior unchanged. ### Explicit Deferrals This release does not implement generics, generic aliases, generic stdlib dispatch, generic vectors, maps, sets, iterators, collection unification, stable collection ABI/layout, or new standard-library APIs. ## 1.0.0-beta.8 Release label: `1.0.0-beta.8` Release date: 2026-05-22 Release state: released beta concrete type alias foundation update ### Summary Glagol `1.0.0-beta.8` is scoped to transparent concrete type aliases. A source module may declare `(type Alias TargetType)` for an existing supported concrete type and then use `Alias` in supported type positions. The alias is not a new runtime type and must be normalized before backend/ABI behavior. - Parse top-level `(type Alias TargetType)` declarations. - Resolve aliases to existing supported concrete target types before typed-core lowering, checked import signatures, LLVM/backend layout, ABI decisions, and runtime behavior. - Format aliases canonically as one-line top-level declarations. - Diagnose malformed aliases, duplicate alias/type/value names, unknown or unsupported target types, cycles, exported aliases, imported aliases, and parameterized/generic alias attempts. - Keep runtime behavior unchanged: no new compiler-known runtime names, hosted symbols, maps/sets, generic aliases, parameterized aliases, or cross-module alias visibility. ### Explicit Deferrals This release does not add generics, parameterized aliases, alias exports/imports, alias re-exports, cross-module alias visibility, maps/sets, stable layout names, runtime helpers, hosted runtime symbols, or standard-library API freeze claims. ## 1.0.0-beta.7 Release label: `1.0.0-beta.7` Release date: 2026-05-22 Release state: serialization/data-interchange beta update ### Summary Glagol `1.0.0-beta.7` keeps the `1.0.0-beta` compiler support baseline and adds the first narrow JSON construction foundation: - compiler-known `std.json.quote_string` - POSIX-hosted runtime support through `__glagol_json_quote_string` - deterministic interpreter/test-runner behavior for JSON quoting tests - focused lowering, diagnostics, source-facade, promotion, hosted runtime, and benchmark-scaffold coverage ### Explicit Deferrals This release does not add JSON parsing, recursive JSON values, maps/sets, generic collections, streaming encoders, schema validation, Unicode normalization, stable text encoding policy beyond the current null-terminated runtime string ABI, or a stable standard-library API freeze. ## 1.0.0-beta.6 Release label: `1.0.0-beta.6` Release date: 2026-05-22 Release state: networking foundation beta update ### Summary Glagol `1.0.0-beta.6` keeps the `1.0.0-beta` compiler support baseline and adds the first narrow networking foundation: - compiler-known `std.net.tcp_connect_loopback_result`, `std.net.tcp_listen_loopback_result`, `std.net.tcp_bound_port_result`, `std.net.tcp_accept_result`, `std.net.tcp_read_all_result`, `std.net.tcp_write_text_result`, and `std.net.tcp_close_result` - POSIX loopback TCP runtime helpers using opaque process-local `i32` handles and concrete `result` values - deterministic interpreter/test-runner error behavior for `std.net` invalid handles and ports - focused lowering, diagnostics, source-facade, promotion, and hosted loopback smoke tests, with hosted socket smokes skipped only when the local sandbox denies loopback sockets ### Explicit Deferrals This release does not add DNS, TLS, UDP, non-loopback binding, async IO, event loops, HTTP frameworks, rich host-error ADTs, stable socket ABI/layout, automatic resource ownership, or a stable standard-library API freeze. ## 1.0.0-beta.5 Release label: `1.0.0-beta.5` Release date: 2026-05-22 Release state: package/workspace discipline beta update ### Summary Glagol `1.0.0-beta.5` keeps the `1.0.0-beta` compiler support baseline and releases the first package/workspace discipline bundle: - Workspace manifests may now declare `[workspace] default_package = "name"` to choose the build/run entry package when multiple workspace packages contain their entry module. - Workspace loading now diagnoses duplicate member paths after normalization with `DuplicateWorkspaceMember`. - Workspace loading now diagnoses a missing `default_package` reference with `WorkspaceDefaultPackageMissing`, and build/run diagnose a selected package that lacks its entry module with `WorkspaceDefaultPackageEntryMissing`. - `glagol doc -o ` now includes a deterministic workspace summary with members, packages, and local package dependency edges. - `glagol new --template workspace` and the canonical local workspace examples now declare `default_package = "app"`. - `docs/language/PACKAGES.md` now documents the beta local workspace/package rules and the explicit no-registry/no-lockfile policy. ### Explicit Deferrals This release does not add remote registries, lockfiles, semantic-version solving, package publishing, optional/dev/target dependencies, feature flags, build scripts, package archives, or stable package ABI/layout guarantees. ## 1.0.0-beta.4 Release label: `1.0.0-beta.4` Release date: 2026-05-22 Release state: language-usability diagnostics beta update ### Summary Glagol `1.0.0-beta.4` keeps the `1.0.0-beta` compiler support baseline and releases the first language-usability diagnostics bundle: - Project build/run entry diagnostics now use entry-specific codes: `ProjectEntryMainMissing`, `ProjectEntryMainInvalidSignature`, `WorkspaceEntryMainMissing`, and `WorkspaceEntryMainInvalidSignature`. Messages now spell out the required `(fn main () -> i32 ...)` contract and include the found parameter count and return type for invalid signatures. - Non-exhaustive `match` diagnostics now use clearer missing-arm wording and a deterministic found-arm list. ### Explicit Deferrals This release does not change the accepted `main` contract, add argument-taking or `unit`-returning `main`, add type aliases, change `match` semantics, or claim new stable ABI/layout guarantees. ## 1.0.0-beta.3 Release label: `1.0.0-beta.3` Release date: 2026-05-22 Release state: standard-library stabilization beta update ### Summary Glagol `1.0.0-beta.3` keeps the `1.0.0-beta` compiler support baseline and adds the first standard-library stabilization bundle: - `scripts/render-stdlib-api-doc.sh` generates `docs/language/STDLIB_API.md` from repo-root `lib/std/*.slo` - the release gate now verifies that generated standard-library API catalog before tests and smoke checks complete - `examples/projects/stdlib-composition` proves a realistic multi-module standard-library program through `fmt --check`, `check`, `test`, `doc`, and hosted `glagol run` when the local toolchain is available - `compiler/tests/standard_stdlib_composition_beta.rs` gates that composition example and guards against accidental local module copies - project-local `.slovo/` build artifacts are ignored so `glagol run` output stays out of commits ### Explicit Deferrals This release does not add syntax, generics, stable standard-library API promises, stable ABI/layout guarantees, richer host error codes, networking, or async runtime behavior. ## 1.0.0-beta.2 Release label: `1.0.0-beta.2` Release date: 2026-05-22 Release state: runtime/resource foundation beta update ### Summary Glagol `1.0.0-beta.2` contains the first runtime/resource foundation slice: - Glagol recognizes `std.fs.open_text_read_result`, `std.fs.read_open_text_result`, `std.fs.close_result`, `std.fs.exists`, `std.fs.is_file`, `std.fs.is_dir`, `std.fs.remove_file_result`, and `std.fs.create_dir_result` - LLVM lowering maps those calls to private hosted runtime symbols while preserving the existing concrete `result` layouts - the test runner mirrors the hosted runtime policy for open/read/close file handles, status checks, file removal, and single-directory creation - focused tests cover test-runner behavior, private lowering shape, hosted native execution, diagnostics, and the explicit `std.fs` source facade This is still a beta resource foundation only. It does not claim stable descriptor identity, writable streams, binary IO, directory handles, directory enumeration, sockets, async resources, rich host errors, or a stable runtime ABI. ## 1.0.0-beta.1 Release label: `1.0.0-beta.1` Release date: 2026-05-22 Release state: first post-beta tooling hardening release ### Summary Glagol `1.0.0-beta.1` keeps the `1.0.0-beta` language/compiler support baseline and releases the first tooling-hardening slice: - `glagol run ` compiles through the existing hosted native build path, runs the produced executable, forwards stdout/stderr, and returns the program exit status - `glagol clean ` removes generated `.slovo/build` artifacts - `glagol new --template binary|library|workspace` adds library and local workspace scaffolds beside the existing binary default - `scripts/install.sh` installs `bin/glagol`, `share/slovo/std`, and `share/slovo/runtime/runtime.c` - installed native builds discover the runtime C input relative to the executable, with `SLOVO_RUNTIME_C` and `GLAGOL_RUNTIME_C` overrides - the release gate prints a concise final success summary ### Explicit Deferrals This is a toolchain workflow slice only. It does not claim new source syntax, a new stable ABI, a runtime resource model, networking surface, or package registry. ## 1.0.0-beta Release label: `1.0.0-beta` Release date: 2026-05-21 Release state: first real general-purpose beta toolchain release ### Summary Glagol `1.0.0-beta` integrates the completed unsigned `u32` / `u64` compiler and stdlib breadth scope with the already promoted project/package workflow, explicit std-source imports, concrete vector families, fixed arrays, structs, enums, result/option, JSON diagnostics, formatter modes, generated docs, and the paired local release gate. The normative Glagol beta gate is `.llm/V1_0_0_BETA_RELEASE_GATE.md`. The beta workflow proof lives in `compiler/tests/beta_1_0_0.rs`. ### Explicit Deferrals No generics, no maps/sets, no remote registries, no networking/async runtime surface, and no stable ABI/layout guarantees are included by beta. ## exp-125 Release label: `exp-125` Release date: 2026-05-21 Release state: completed experimental precursor scope absorbed into `1.0.0-beta` ### Summary exp-125 completed the connected unsigned `u32` / `u64` compiler and stdlib breadth scope that directly enabled `1.0.0-beta`. ## exp-123 ## exp-124 Release label: `exp-124` Release date: 2026-05-21 Release state: gated experimental fixed-array enum-and-struct-elements compiler slice ### Summary Glagol exp-124 gates one connected compiler broadening: fixed immutable arrays now support direct known enum elements and current known non-recursive struct elements alongside the earlier direct scalar and `string` lanes. The release updates checker admission, formatter array rendering, LLVM fixed-array typing for named element layouts, test-runner array values, machine-diagnostic snapshots, promoted `array-enum` and `array-struct-elements` fixtures and lowering snapshots, focused Glagol tests, `llvm_smoke`/`lowering_inspector` inventories, and promotion-gate alignment. ### Explicit Deferrals No zero-length arrays, no mutable arrays, no element mutation, no array equality, no array printing, no nested arrays, no slices or generics, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-123 Release label: `exp-123` Release date: 2026-05-21 Release state: gated experimental owned-vector benchmark-suite extension and whitepaper refresh ### Summary Glagol exp-123 gates one connected benchmark/publication broadening: the local benchmark scaffold inventory now includes `vec-i32-index-loop` and `vec-string-eq-loop` beside `math-loop`, `branch-loop`, `parse-loop`, `array-index-loop`, `string-eq-loop`, `array-struct-field-loop`, and `enum-struct-payload-loop`. The release keeps the shared runner model intact, adds the two new scaffold directories with Slovo/C/Rust/Python/Clojure/Common Lisp implementations, extends the focused benchmark scaffold test and promotion-gate inventory from seven kernels to nine, reruns local benchmark evidence, and refreshes the Glagol whitepaper/publication docs around the expanded suite and the current experimental compiler surface through `exp-121`. ### Explicit Deferrals No language-surface change, no compiler/runtime widening, no runtime ABI claim, no benchmark thresholds, no cross-machine performance claims, no broad optimizer guarantees, no PDF pipeline redesign, and no beta maturity are included. ## exp-122 Release label: `exp-122` Release date: 2026-05-21 Release state: gated experimental composite-data benchmark-suite extension and whitepaper refresh ### Summary Glagol exp-122 gates one connected benchmark/publication broadening: the local benchmark scaffold inventory now includes `array-struct-field-loop` and `enum-struct-payload-loop` beside `math-loop`, `branch-loop`, `parse-loop`, `array-index-loop`, and `string-eq-loop`. The release keeps the shared runner model intact, adds the two new scaffold directories with Slovo/C/Rust/Python/Clojure/Common Lisp implementations, extends the focused benchmark scaffold test and promotion-gate inventory from five kernels to seven, reruns local benchmark evidence, and refreshes the Glagol whitepaper/publication docs around the expanded suite and the current experimental compiler surface through `exp-121`. During the final gate pass, Glagol also tightened one existing backend path: `none f64` option aggregates now emit a typed `double 0.0` zero payload instead of invalid `double 0`, preserving the already promoted `option f64` surface under the clang-backed LLVM smoke gate. ### Explicit Deferrals No language-surface change, no runtime ABI claim, no benchmark thresholds, no cross-machine performance claims, no broad optimizer guarantees, no PDF pipeline redesign, and no beta maturity are included. ## exp-121 Release label: `exp-121` Release date: 2026-05-21 Release state: gated experimental non-recursive-struct enum-payload compiler slice ### Summary Glagol exp-121 gates one connected enum-payload broadening: unary enum payload variants now support current known non-recursive struct types. The release updates checker and formatter payload admission, LLVM enum aggregate lowering and zero-payload handling, test-runner struct payload support, machine-diagnostic snapshots, the promoted `enum-payload-structs` fixture and lowering snapshots, focused `enum_payload_structs_alpha` coverage, and promotion-gate alignment. The fixture intentionally uses an array-bearing struct payload so exp-120 is exercised indirectly without widening enums to direct array payloads. ### Explicit Deferrals No direct array/vec/option/result payloads, no equality requirement for struct-payload enums, no mutation, no recursive/cyclic payloads, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-120 Release label: `exp-120` Release date: 2026-05-21 Release state: gated experimental fixed-array struct-field compiler slice ### Summary Glagol exp-120 gates one connected compiler broadening: direct struct field declarations now support the already promoted fixed immutable array families `(array i32 N)`, `(array i64 N)`, `(array f64 N)`, `(array bool N)`, and `(array string N)`. The release updates struct-field checker admission, machine-diagnostic snapshots, the promoted `array-struct-fields` fixture and lowering snapshots, focused `array_struct_fields_alpha` coverage, `llvm_smoke`/`lowering_inspector` inventory, and promotion-gate alignment. The earlier array fixtures remain valid as the underlying fixed-array lanes, and the earlier struct-field fixtures remain valid as narrower sibling lanes. ### Explicit Deferrals No zero-length arrays, no mutable arrays, no element mutation, no field mutation, no nested arrays, no arrays of unsupported element kinds, no array equality, no array printing, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-119 Release label: `exp-119` Release date: 2026-05-21 Release state: gated experimental benchmark-suite extension and whitepaper refresh ### Summary Glagol exp-119 gates one connected benchmark/publication broadening: the local benchmark scaffold inventory now includes `array-index-loop` and `string-eq-loop` beside the existing `math-loop`, `branch-loop`, and `parse-loop` kernels. The release keeps the shared runner model intact, adds the two new scaffold directories with Slovo/C/Rust/Python/Clojure/Common Lisp implementations, extends the focused benchmark scaffold test and promotion-gate inventory, and refreshes the Glagol whitepaper/publication docs around the expanded suite and the current experimental compiler surface. ### Explicit Deferrals No language-surface change, no runtime ABI claim, no benchmark thresholds, no cross-machine performance claims, no broad optimizer guarantees, no PDF pipeline redesign, and no beta maturity are included. ## exp-118 Release label: `exp-118` Release date: 2026-05-21 Release state: gated experimental string fixed-array compiler slice ### Summary Glagol exp-118 gates one connected compiler broadening: fixed immutable arrays now support `string` elements as a sibling lane beside the already promoted direct scalar `i32`, `i64`, `f64`, and `bool` families. The release updates array checker admission, formatter array rendering, LLVM array typing/load/store/index lowering, test-runner array values, diagnostics coverage, the promoted `array-string` and `array-string-value-flow` fixtures and lowering snapshots, focused array-string tests, the promotion-gate inventory, and the Glagol docs for this feature. The earlier `array.slo`, `array-value-flow.slo`, `array-direct-scalars.slo`, and `array-direct-scalars-value-flow.slo` fixtures remain valid as the predecessor lanes. ### Explicit Deferrals No array mutation, no array equality, no array printing, no nested arrays, no arrays in struct fields, no zero-length arrays, no slices, no generics, no new compiler-known runtime names, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-117 Release label: `exp-117` Release date: 2026-05-21 Release state: gated experimental direct-scalar fixed-array compiler slice ### Summary Glagol exp-117 gates one connected compiler broadening: fixed immutable arrays now support the direct scalar element families `i32`, `i64`, `f64`, and `bool` instead of only `i32`. The release updates array checker admission, formatter array rendering, LLVM array typing/load/store/index lowering, test-runner array values, diagnostics coverage, the promoted `array-direct-scalars` and `array-direct-scalars-value-flow` fixtures and lowering snapshots, focused array tests, the promotion-gate inventory, and the Glagol docs for this feature. The earlier `array.slo` and `array-value-flow.slo` fixtures remain valid as the narrower `i32` predecessor lane. ### Explicit Deferrals No string arrays, no array mutation, no array equality, no array printing, no nested arrays, no arrays in struct fields, no zero-length arrays, no slices, no generics, no new compiler-known runtime names, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-116 Release label: `exp-116` Release date: 2026-05-21 Release state: gated experimental direct enum-payload compiler slice ### Summary Glagol exp-116 gates one connected compiler broadening: user-defined enum payload variants now support unary direct `i32`, `i64`, `f64`, `bool`, and `string` payloads instead of unary `i32` only. The release keeps payloadless variants supported, keeps exactly one payload per payload variant, and adds one conservative same-payload-kind-per-enum rule whenever payload variants appear. That constraint keeps each enum on one concrete LLVM payload layout without inventing generic sum-layout machinery. The release updates the enum checker path, formatter enum rendering, LLVM enum layout/equality/match lowering, test-runner enum payload support, project/workspace enum import coverage, diagnostics coverage, the promoted `enum-payload-direct-scalars` fixture and lowering snapshots, focused enum-payload tests, the promotion-gate inventory, and the Glagol docs for this feature. ### Explicit Deferrals No vec/array/option/result/struct/enum payloads, no mixed payload kinds inside one enum, no generics, no payload mutation, no new parser forms, no new typed-AST constructs, no new compiler-known runtime names, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-115 Release label: `exp-115` Release date: 2026-05-21 Release state: gated experimental composite-struct-field compiler slice ### Summary Glagol exp-115 gates one connected compiler broadening: direct struct fields now support the current concrete vec families, current concrete option/result families, and current non-recursive struct types alongside the already promoted direct scalar, string, and enum field families. The release updates the struct-field checker path, recursive-layout rejection, formatter struct-field rendering, diagnostics coverage, the promoted `composite-struct-fields` fixture and lowering snapshots, focused composite-struct tests, the promotion-gate inventory, and the Glagol docs for this feature. Lowering and typed AST forms do not widen: direct struct declarations, constructors, field access, and current composite value families already existed, so the release keeps the delta in checker/formatter/test/docs rather than introducing new syntax or runtime names. ### Explicit Deferrals No arrays as struct fields, no field mutation, no vector element mutation, no option/result payload mutation, no recursive or cyclic struct layouts, no new parser forms, no new typed-AST constructs, no new compiler-known runtime names, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-113 Release label: `exp-113` Release date: 2026-05-21 Release state: gated experimental mutable scalar-local compiler slice ### Summary Glagol exp-113 gates one narrow compiler broadening: mutable `bool`, `i64`, and `f64` locals now work through `var` and `set`. The release updates the local-type checker path, formatter local-type messaging, LLVM local emission, diagnostics coverage, the promoted local-variable fixture and lowering snapshots, focused mutable-scalar tests, the promotion-gate inventory, and the Glagol docs for this feature. Lowering and typed AST forms do not widen: `lower_type`, `var`, and `set` already existed, so the release keeps the delta in checker/backend/test/docs rather than introducing new syntax or runtime names. ### Explicit Deferrals No mutable `string`, vector, option/result, struct, or enum locals, no new parser forms, no new typed-AST constructs, no new compiler-known runtime names, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-114 Release label: `exp-114` Release date: 2026-05-21 Release state: gated experimental mutable composite-local compiler slice ### Summary Glagol exp-114 gates one narrow compiler broadening: same-type mutable local reassignment now works through `var` and `set` for `string`, the current concrete vec families, the current concrete option/result families, known struct values, and current enum values. The release updates the local-type checker path, mutable assignment gate, formatter local rendering, LLVM local emission, diagnostics coverage, the promoted `composite-locals` fixture and lowering snapshots, focused mutable-composite tests, the promotion-gate inventory, and the Glagol docs for this feature. Lowering and typed AST forms do not widen: `lower_type`, `var`, `set`, and `match` already existed, so the release keeps the delta in checker/backend/test/docs rather than introducing new syntax or runtime names. ### Explicit Deferrals No mutable arrays, no field/element/payload mutation, no mutable generics or new value families, no new parser forms, no new typed-AST constructs, no new compiler-known runtime names, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-112 Release label: `exp-112` Release date: 2026-05-21 Release state: gated experimental immutable bool-local compiler slice ### Summary Glagol exp-112 gates one narrow compiler broadening: immutable `bool` locals now work in `let` bindings. The release updates the local-type checker path, LLVM local emission, diagnostics coverage, one focused bool-local integration test, the promotion-gate diagnostic inventory, and the Glagol docs for this feature. Lowering and typed AST forms do not widen: `lower_type` already accepted `bool`, and the release keeps the feature limited to immutable `let` bindings only. ### Explicit Deferrals No mutable `bool` locals, no new parser forms, no new compiler-known runtime names, no broader local-mutation semantics, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-111 Release label: `exp-111` Release date: 2026-05-21 Release state: gated experimental io stdin-helper stdlib gate ### Summary Glagol exp-111 gates one connected broadening of the existing `std.io` helper lane. The release keeps the already promoted compiler/runtime semantics unchanged and instead broadens the existing local and explicit-source `std.io` fixtures, the focused source-helper/source-search tests, and the promotion-gate inventory with: - `read_stdin_result` - `read_stdin_option` - `read_stdin_or` - `read_stdin_i32_result` - `read_stdin_i32_option` - `read_stdin_i32_or_zero` - `read_stdin_i32_or` - `read_stdin_i64_result` - `read_stdin_i64_option` - `read_stdin_i64_or_zero` - `read_stdin_i64_or` - `read_stdin_f64_result` - `read_stdin_f64_option` - `read_stdin_f64_or_zero` - `read_stdin_f64_or` - `read_stdin_bool_result` - `read_stdin_bool_option` - `read_stdin_bool_or_false` - `read_stdin_bool_or` The helper lane stays source-authored over the already promoted `std.io.read_stdin_result`, the released `std.string.parse_*_result` helpers, and the exp-109 `ok_or_none_*` bridge helpers. The Glagol local fixture adds explicit local `result.slo` and `string.slo` bridge modules so the widened io facade remains ordinary source composition rather than new compiler-known runtime names. ### Explicit Deferrals No parser/checker/backend/runtime widening, no new compiler-known `std.*` runtime names, no trap-based `std.io.read_stdin`, no line/read-line or prompt APIs, no terminal mode, no binary/streaming/async stdin, no automatic std imports, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-110 Release label: `exp-110` Release date: 2026-05-21 Release state: gated experimental string/env/fs/process/cli option-helper stdlib gate ### Summary Glagol exp-110 gates one connected broadening of the existing `std.string`, `std.env`, `std.fs`, `std.process`, and `std.cli` helper lanes. The release keeps the already promoted compiler/runtime semantics unchanged and instead broadens the existing local and explicit-source fixtures, the focused source-helper/source-search tests, and the promotion-gate inventory with: - `parse_i32_option` - `parse_i64_option` - `parse_f64_option` - `parse_bool_option` - `get_option` - `get_i32_option` - `get_i64_option` - `get_f64_option` - `get_bool_option` - `read_text_option` - `read_i32_option` - `read_i64_option` - `read_f64_option` - `read_bool_option` - `arg_option` - `arg_i32_option` - `arg_i64_option` - `arg_f64_option` - `arg_bool_option` - `arg_text_option` - `arg_i32_option` - `arg_i64_option` - `arg_f64_option` - `arg_bool_option` The helper lanes stay source-authored over the already promoted concrete result families plus the exp-109 `ok_or_none_*` bridge helpers. The Glagol local fixtures add explicit local `result.slo` bridge modules so the option helpers remain ordinary source composition rather than new compiler-known runtime names. ### Explicit Deferrals No parser/checker/backend/runtime widening, no new compiler-known `std.*` runtime names, no stdin helpers, no vec work, no automatic std imports, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-109 Release label: `exp-109` Release date: 2026-05-21 Release state: gated experimental option/result bridge stdlib gate ### Summary Glagol exp-109 gates one connected broadening of the existing `std.option` and `std.result` helper lanes. The release keeps the already promoted concrete option/result semantics unchanged and instead broadens the local `std-layout-local-option/` and `std-layout-local-result/` fixtures, the explicit `std-import-option/` and `std-import-result/` fixtures, the workspace `std-import-option/` fixture, the focused source-helper/source-search tests, and the promotion-gate inventory with: - `some_or_err_i32` - `some_or_err_i64` - `some_or_err_f64` - `some_or_err_bool` - `some_or_err_string` - `ok_or_none_i32` - `ok_or_none_i64` - `ok_or_none_string` - `ok_or_none_f64` - `ok_or_none_bool` The helper lanes stay concrete and source-authored over the already promoted option/result forms. `std.option` uses raw `ok` and `err` constructors directly, and `std.result` uses raw `some` and `none` constructors directly, without introducing local bridge shim modules, new compiler-known `std.option.*` or `std.result.*` runtime names, or compiler/runtime widening. ### Explicit Deferrals No new compiler-known `std.*` runtime names, no generics, no broader `map`/`and_then`/`transpose`/`flatten` package, no new payload families, no automatic or compiler-loaded std imports, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-108 Release label: `exp-108` Release date: 2026-05-21 Release state: gated experimental vec-string/vec-f64/vec-bool prefix/suffix stdlib gate ### Summary Glagol exp-108 gates one connected broadening of the existing vec-string, vec-f64, and vec-bool helper lanes. The release keeps the already promoted concrete `(vec string)`, `(vec f64)`, and `(vec bool)` compiler/runtime semantics unchanged and instead broadens the local `std-layout-local-vec_string/`, `std-layout-local-vec_f64/`, and `std-layout-local-vec_bool/` fixtures, the explicit `std-import-vec_string/`, `std-import-vec_f64/`, and `std-import-vec_bool/` fixtures, the focused source-helper/source-search tests, and the promotion-gate inventory with: - `starts_with` - `without_prefix` - `ends_with` - `without_suffix` The helper lanes stay recursive and immutable with no `var` or `set`, stay concrete to the three existing vec families, and reuse only the already promoted runtime names: - `std.vec.string.empty` - `std.vec.string.append` - `std.vec.string.len` - `std.vec.string.index` - `std.vec.f64.empty` - `std.vec.f64.append` - `std.vec.f64.len` - `std.vec.f64.index` - `std.vec.bool.empty` - `std.vec.bool.append` - `std.vec.bool.len` - `std.vec.bool.index` ### Explicit Deferrals No new compiler-known `std.*` runtime names, no generics, no sorting, mapping, filtering, no nested/container vecs, no mutating or capacity APIs, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-107 Release label: `exp-107` Release date: 2026-05-21 Release state: gated experimental vec-string/vec-f64/vec-bool edit-helper stdlib gate ### Summary Glagol exp-107 gates one connected broadening of the existing vec-string, vec-f64, and vec-bool helper lanes. The release keeps the already promoted concrete `(vec string)`, `(vec f64)`, and `(vec bool)` compiler/runtime semantics unchanged and instead broadens the local `std-layout-local-vec_string/`, `std-layout-local-vec_f64/`, and `std-layout-local-vec_bool/` fixtures, the explicit `std-import-vec_string/`, `std-import-vec_f64/`, and `std-import-vec_bool/` fixtures, the focused source-helper/source-search tests, and the promotion-gate inventory with: - `insert_at` - `insert_range` - `replace_at` - `replace_range` - `remove_at` - `remove_range` The helper lanes stay recursive and immutable with no `var` or `set`, stay concrete to the three existing vec families, and reuse only the already promoted runtime names: - `std.vec.string.empty` - `std.vec.string.append` - `std.vec.string.len` - `std.vec.string.index` - `std.vec.f64.empty` - `std.vec.f64.append` - `std.vec.f64.len` - `std.vec.f64.index` - `std.vec.bool.empty` - `std.vec.bool.append` - `std.vec.bool.len` - `std.vec.bool.index` ### Explicit Deferrals No new compiler-known `std.*` runtime names, no generics, no prefix/suffix helpers, no sorting/mapping/filtering, no nested/container vecs, no mutating or capacity APIs, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-106 Release label: `exp-106` Release date: 2026-05-21 Release state: gated experimental vec-f64/vec-bool option-query stdlib gate ### Summary Glagol exp-106 gates one connected broadening of the existing vec-f64 and vec-bool helper lanes. The release keeps the already promoted concrete `(vec f64)` and `(vec bool)` compiler/runtime semantics unchanged and instead broadens the local `std-layout-local-vec_f64/` and `std-layout-local-vec_bool/` fixtures, the explicit `std-import-vec_f64/` and `std-import-vec_bool/` fixtures, the focused source-helper/source-search tests, and the promotion-gate inventory with: - `index_option` - `first_option` - `last_option` - `index_of_option` - `last_index_of_option` The helper lanes stay recursive and immutable with no `var` or `set`, stay concrete to `(vec f64)` and `(vec bool)` plus the already promoted concrete option families they return, and reuse only the already promoted runtime names: - `std.vec.f64.empty` - `std.vec.f64.append` - `std.vec.f64.len` - `std.vec.f64.index` - `std.vec.bool.empty` - `std.vec.bool.append` - `std.vec.bool.len` - `std.vec.bool.index` ### Explicit Deferrals No new compiler-known `std.*` runtime names, no generics, no edit helpers, no nested/container vecs, no mutating or capacity APIs, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-105 Release label: `exp-105` Release date: 2026-05-21 Release state: gated experimental vec-f64/vec-bool transform-helper stdlib gate ### Summary Glagol exp-105 gates one connected broadening of the existing vec-f64 and vec-bool helper lanes. The release keeps the already promoted concrete `(vec f64)` and `(vec bool)` compiler/runtime semantics unchanged and instead broadens the local `std-layout-local-vec_f64/` and `std-layout-local-vec_bool/` fixtures, the explicit `std-import-vec_f64/` and `std-import-vec_bool/` fixtures, the focused source-helper/source-search tests, and the promotion-gate inventory with: - `concat` - `take` - `drop` - `reverse` - `subvec` The helper lanes stay recursive and immutable with no `var` or `set`, stay concrete to `(vec f64)` and `(vec bool)` only, and reuse only the already promoted runtime names: - `std.vec.f64.empty` - `std.vec.f64.append` - `std.vec.f64.len` - `std.vec.f64.index` - `std.vec.bool.empty` - `std.vec.bool.append` - `std.vec.bool.len` - `std.vec.bool.index` ### Explicit Deferrals No new compiler-known `std.*` runtime names, no generics, no option/result helpers, no edit helpers, no nested/container vecs, no mutating or capacity APIs, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-104 Release label: `exp-104` Release date: 2026-05-21 Release state: gated experimental vec-bool baseline compiler/runtime plus stdlib gate ### Summary Glagol exp-104 gates the first concrete `(vec bool)` slice. The release extends the checker, formatter, LLVM backend, runtime, std runtime inventory, and test runner so immutable `(vec bool)` params, returns, locals, direct `std.vec.bool.empty/append/len/index` calls, and same-family vec-bool equality work end to end. It also adds the small scalar bool-equality enablement required by the source-authored helper lane. The release adds the local `std-layout-local-vec_bool/` fixture, the explicit `std-import-vec_bool/` fixture, focused vec-bool collections/source helper/ source search coverage, diagnostics snapshot refreshes, and promotion-gate inventory for the connected `std.vec_bool` helper inventory: - `empty` - `append` - `len` - `at` - `singleton` - `append2` - `append3` - `pair` - `triple` - `is_empty` - `index_or` - `first_or` - `last_or` - `contains` - `count_of` The source helpers stay recursive and immutable with no `var` or `set`, stay concrete to `(vec bool)` only, and reuse only the already promoted `std.vec.bool.empty`, `std.vec.bool.append`, `std.vec.bool.len`, and `std.vec.bool.index` runtime names. ### Explicit Deferrals No new compiler-known `std.*` runtime names beyond the vec-bool family, no generics, no option-query helpers, no transform/edit helpers, no nested vecs or vecs inside other containers, no mutating or capacity APIs, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-103 Release label: `exp-103` Release date: 2026-05-21 Release state: gated experimental vec-f64 baseline compiler/runtime plus stdlib gate ### Summary Glagol exp-103 gates the first concrete `(vec f64)` slice. The release extends the checker, formatter, LLVM backend, runtime, std runtime inventory, and test runner so immutable `(vec f64)` params, returns, locals, direct `std.vec.f64.empty/append/len/index` calls, and same-family vec-f64 equality work end to end. It also adds the local `std-layout-local-vec_f64/` fixture, the explicit `std-import-vec_f64/` fixture, focused vec-f64 diagnostics and promotion-gate coverage, and the connected `std.vec_f64` helper inventory: - `empty` - `append` - `len` - `at` - `singleton` - `append2` - `append3` - `pair` - `triple` - `is_empty` - `index_or` - `first_or` - `last_or` - `contains` - `sum` The source helpers stay recursive and immutable with no `var` or `set`, stay concrete to `(vec f64)` only, and reuse only the already promoted `std.vec.f64.empty`, `std.vec.f64.append`, `std.vec.f64.len`, and `std.vec.f64.index` runtime names. ### Explicit Deferrals No new compiler-known `std.*` runtime names beyond the vec-f64 family, no generics, no option-query helpers, no transform/edit helpers, no nested vecs or vecs inside other containers, no mutating or capacity APIs, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-102 Release label: `exp-102` Release date: 2026-05-21 Release state: gated experimental option-bool-f64 baseline compiler/runtime plus stdlib gate ### Summary Glagol exp-102 gates the concrete `(option f64)` and `(option bool)` slice. The release extends the checker, formatter, LLVM backend, and test runner so immutable `(option f64)` and `(option bool)` params, returns, locals, direct `some`/`none` construction, `is_some`, `is_none`, `unwrap_some`, and source-level `match` payload binding work end to end. It also broadens the local `std-layout-local-option/` fixture, the explicit `std-import-option/` fixture, the workspace `std-import-option/` fixture, focused option-result coverage, diagnostics snapshots, and promotion-gate inventory, and it stages the connected `std.option` f64/bool helper inventory: - `some_f64` - `none_f64` - `is_some_f64` - `is_none_f64` - `unwrap_some_f64` - `unwrap_or_f64` - `some_bool` - `none_bool` - `is_some_bool` - `is_none_bool` - `unwrap_some_bool` - `unwrap_or_bool` The source helpers stay explicit and concrete, and the compiler/runtime slice stays concrete to `(option i32)`, `(option i64)`, `(option f64)`, `(option bool)`, and `(option string)`. ### Explicit Deferrals No compiler-known `std.option.*` runtime names, no generic option helpers, no option payload families beyond `i32`, `i64`, `f64`, `bool`, and `string`, no nested or container option support, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-101 Release label: `exp-101` Release date: 2026-05-21 Release state: gated experimental vec-string option/transform stdlib gate ### Summary Glagol exp-101 gates the broadened concrete `(vec string)` helper lane. The release updates the local `std-layout-local-vec_string/` fixture, the explicit `std-import-vec_string/` fixture, focused vec-string source-helper and source-search coverage, and promotion-gate inventory with one connected helper package: - `index_option` - `first_option` - `last_option` - `index_of_option` - `last_index_of_option` - `concat` - `take` - `drop` - `reverse` - `subvec` The source helpers stay recursive and immutable with no `var` or `set`, stay concrete to `(vec string)` plus raw current `(option string)` / `(option i32)` forms only, and reuse only the already promoted `std.vec.string.empty`, `std.vec.string.append`, `std.vec.string.len`, and `std.vec.string.index` runtime names. ### Explicit Deferrals No new compiler-known `std.*` runtime names, no generics, no edit helpers, no prefix/suffix helpers, no nested vecs or vecs inside other containers, no mutating or capacity APIs, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-100 Release label: `exp-100` Release date: 2026-05-21 Release state: gated experimental option-string baseline compiler/runtime plus stdlib gate ### Summary Glagol exp-100 gates the first concrete `(option string)` slice. The release extends the checker, formatter, LLVM backend, and test runner so immutable `(option string)` params, returns, locals, direct `some`/`none` construction, `is_some`, `is_none`, `unwrap_some`, and source-level `match` payload binding work end to end. It also broadens the local `std-layout-local-option/` fixture, the explicit `std-import-option/` fixture, the workspace `std-import-option/` fixture, focused option/result coverage, and promotion-gate inventory, and it stages the connected `std.option` string helper inventory: - `some_string` - `none_string` - `is_some_string` - `is_none_string` - `unwrap_some_string` - `unwrap_or_string` The source helpers stay explicit and concrete, and the compiler/runtime slice stays concrete to `(option i32)`, `(option i64)`, and `(option string)`. ### Explicit Deferrals No compiler-known `std.option.*` runtime names, no generic option helpers, no option payload families beyond `i32`, `i64`, and `string`, no nested or container option support, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-99 Release label: `exp-99` Release date: 2026-05-21 Release state: gated experimental vec-string baseline compiler/runtime plus stdlib gate ### Summary Glagol exp-99 gates the first concrete `(vec string)` slice. The release extends the checker, formatter, LLVM backend, runtime, std runtime inventory, and test runner so immutable `(vec string)` params, returns, locals, direct `std.vec.string.empty`, `std.vec.string.append`, `std.vec.string.len`, `std.vec.string.index`, and concrete vec-string equality work end to end. It also adds `examples/vec-string.slo`, adds the local `std-layout-local-vec_string/` fixture, adds the explicit `std-import-vec_string/` fixture, adds focused diagnostics and promotion-gate coverage, and stages the frozen `std.vec_string` helper inventory: - `empty` - `append` - `len` - `at` - `singleton` - `append2` - `append3` - `pair` - `triple` - `is_empty` - `index_or` - `first_or` - `last_or` - `contains` - `count_of` The source helpers stay recursive and immutable with no `var` or `set`, use only the promoted `std.vec.string` runtime names, and keep real-program coverage focused on `contains` and `count_of`. In Glagol-only repo states, the explicit-source `std-import-vec_string/` fixture now remains authored and format-checked even if sibling `lib/std/vec_string.slo` has not landed yet; the full check/test lane for that fixture still depends on the paired Slovo source file. ### Explicit Deferrals No generics, no other vec element families, no option-query helpers, no transform/range/edit helpers, no nested vecs or vecs inside other containers, no mutating or capacity APIs, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-98 Release label: `exp-98` Release date: 2026-05-21 Release state: gated experimental vec-i64-edit-helper stdlib gate ### Summary Glagol exp-98 gates the concrete edit-helper extension for the staged `std.vec_i64` source-authored facade. The release updates the local `std-layout-local-vec_i64/` fixture, updates the explicit `std-import-vec_i64/` fixture against repo-root `lib/std/vec_i64.slo`, adds focused integration coverage, and extends promotion-gate inventory and sibling Slovo alignment checks for these helpers: - `insert_at` - `insert_range` - `replace_at` - `replace_range` - `remove_at` - `remove_range` The helpers reuse only the existing `std.vec.i64` runtime family plus the already promoted `(option i32)` and `(option i64)` surface. `insert_at(values,position,value)` inserts before `position`, appends when `position == len(values)`, and otherwise leaves out-of-range inputs unchanged. `insert_range(values,position,inserted)` follows the same position rules while preserving left-to-right order of both vectors. `replace_at` and `remove_at` leave negative and out-of-range positions unchanged. The range helpers leave `values` unchanged for negative starts, degenerate or reversed ranges, and `start >= len(values)`; overlong `end_exclusive` values edit through the tail; and valid edits preserve element order while leaving source vectors unchanged. The local Glagol-owned fixture stays source-authored, recursive, and immutable without `var` or `set`, and the release adds no new parser, checker, runtime, formatter, or LLVM semantics. ### Explicit Deferrals No generic vectors, no new compiler-known `std.*` runtime names, no automatic standard-library imports, no compiler-loaded std source, no mutable vector APIs, no capacity/reserve management, no iterators, sorting, mapping, filtering, stable ABI/layout guarantees, or beta maturity are included. ## exp-97 Release label: `exp-97` Release date: 2026-05-21 Release state: gated experimental vec-i64-transform-helper stdlib gate ### Summary Glagol exp-97 gates the concrete transform-helper extension for the staged `std.vec_i64` source-authored facade. The release updates the local `std-layout-local-vec_i64/` fixture, updates the explicit `std-import-vec_i64/` fixture against repo-root `lib/std/vec_i64.slo`, adds focused integration coverage, and extends promotion-gate inventory and sibling Slovo alignment checks for these helpers: - `concat` - `take` - `drop` - `reverse` - `subvec` The helpers reuse only the existing `std.vec.i64` runtime family plus the already promoted `(option i32)` and `(option i64)` surface. `concat(left,right)` preserves left-to-right element order, `take(values,count)` treats negative counts as zero and saturates to the full vector, `drop(values,count)` treats negative counts as zero and saturates to the empty vector, `reverse(values)` returns a new vector in reverse order, and `subvec(values,start,end_exclusive)` returns the bounded middle slice while using the same concrete vec_i64 lane. The local Glagol-owned fixture stays source-authored, recursive, and immutable without `var` or `set`, and the release adds no new parser, checker, runtime, formatter, or LLVM semantics. ### Explicit Deferrals No vec_i64 insert/replace/remove helpers, no generics, no new compiler-known `std.*` runtime names, no mutating vector or capacity APIs, no iterators, sorting, mapping, filtering, stable ABI/layout guarantees, or beta maturity are included. ## exp-96 Release label: `exp-96` Release date: 2026-05-20 Release state: gated experimental vec-i64-option-query-helper stdlib gate ### Summary Glagol exp-96 gates the concrete option-query helper extension for the staged `std.vec_i64` source-authored facade. The release updates the local `std-layout-local-vec_i64/` fixture, updates the explicit `std-import-vec_i64/` fixture against repo-root `lib/std/vec_i64.slo`, adds focused integration coverage, and extends promotion-gate inventory and sibling Slovo alignment checks for these helpers: - `index_option` - `first_option` - `last_option` - `index_of_option` - `last_index_of_option` The helpers reuse only the existing `std.vec.i64` runtime family plus the already promoted `(option i32)` and `(option i64)` surface. `index_option(values,position)`, `first_option(values)`, and `last_option(values)` return concrete `(option i64)` observations of vec elements; `index_of_option(values,target)` and `last_index_of_option(values,target)` return concrete `(option i32)` position results. The local Glagol-owned fixture stays source-authored, recursive, and immutable without `var` or `set`, and the release adds no new parser, checker, runtime, formatter, or LLVM semantics. ### Explicit Deferrals No vec_i64 transform/range/edit helpers, no generics, no new compiler-known `std.*` runtime names, no mutating vector or capacity APIs, no iterators, sorting, mapping, filtering, stable ABI/layout guarantees, or beta maturity are included. ## exp-95 Release label: `exp-95` Release date: 2026-05-20 Release state: gated experimental option-i64-baseline compiler/runtime and stdlib gate ### Summary Glagol exp-95 gates the first concrete `(option i64)` baseline across the compiler, local source fixtures, and explicit-source `std.option` import path. The release broadens the checker, formatter, LLVM backend, and test runner so immutable `(option i64)` params, returns, locals, `some`, `none`, `is_some`, `is_none`, `unwrap_some`, and source-level `match` payload bindings work end to end. It adds the local `std-layout-local-option/` i64 helper coverage, widens the explicit `std-import-option/` project against repo-root `lib/std/option.slo`, extends diagnostics snapshots and promotion-gate inventory, and broadens the staged helper surface with: - `some_i64` - `none_i64` - `is_some_i64` - `is_none_i64` - `unwrap_some_i64` - `unwrap_or_i64` ### Explicit Deferrals No compiler-known `std.option.*` runtime names, no generic option helpers, no option payload families beyond `i32` and `i64`, no nested/container option support, no option equality or printing, no stable ABI/layout guarantee, no manifest schema changes, and no beta maturity are included. ## exp-94 Release label: `exp-94` Release date: 2026-05-20 Release state: gated experimental vec-i64-baseline compiler/runtime and stdlib gate ### Summary Glagol exp-94 gates the concrete `(vec i64)` runtime and compiler surface plus the first local and explicit-source `std.vec_i64` facade baseline. The release promotes `std.vec.i64.empty`, `std.vec.i64.append`, `std.vec.i64.len`, and `std.vec.i64.index`; adds `(vec i64)` equality; extends the checker, formatter, lowering, LLVM backend, runtime, test runner, and runtime catalog for concrete `(vec i64)` values; adds the local `std-layout-local-vec_i64/` fixture; adds the explicit `std-import-vec_i64/` fixture against repo-root `lib/std/vec_i64.slo`; adds focused integration coverage; and extends promotion-gate inventory for this connected baseline: - `empty` - `append` - `len` - `at` - `singleton` - `append2` - `append3` - `pair` - `triple` - `is_empty` - `index_or` - `first_or` - `last_or` - `contains` - `sum` The source surface stays concrete to `(vec i64)` and immutable. It reuses only the promoted `std.vec.i64` runtime names, leaves source vectors unchanged, and does not widen option/result payload families or introduce generic vector semantics. ### Explicit Deferrals No generic vectors, no vector payload families beyond the concrete `(vec i32)` and `(vec i64)` slices, no automatic standard-library imports, no edits under `slovo/**`, no compiler-loaded std source beyond the existing explicit search rules, no new compiler-known `std.*` runtime names beyond `std.vec.i64.*`, no slice or view types, no mutable vector locals, no mutating vector APIs, no option/result payload widening, no vector families for `f64`, `string`, or `bool`, no capacity or reserve management, no sorting, mapping, filtering, or iterator APIs, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-93 Release label: `exp-93` Release date: 2026-05-20 Release state: gated experimental vec-i32-count-of-helper stdlib gate ### Summary Glagol exp-93 gates the concrete count-of helper extension for the staged `std.vec_i32` source-authored facade. The release updates the explicit `std-import-vec_i32/` project, updates the local source-authored `std-layout-local-vec_i32/` fixture, adds focused integration coverage, and extends promotion-gate inventory and sibling Slovo alignment checks for this helper: - `count_of` The helper is an ordinary source-authored composition over the existing promoted `std.vec.i32` runtime family and the already staged `std.vec_i32` wrappers for `len` and `at`, plus equality and `while`. `count_of(values,target)` returns the number of elements of `values` equal to `target`; returns `0` for empty and no-match cases; counts repeated matches exactly; leaves the source vector unchanged; and adds no new parser, checker, runtime, formatter, or LLVM semantics for this release. ### Explicit Deferrals No generic vectors, no vector payload families beyond `(vec i32)`, no automatic standard-library imports, no compiler-loaded std source, no new compiler-known `std.*` runtime names, no new private recursive helper loops, no broader aggregation/filter families beyond the current concrete vec surface, no slice or view types, no mutable `(vec i32)` local support, no capacity or reserve management, no sorting, mapping, filtering, or iterator APIs, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-92 Release label: `exp-92` Release date: 2026-05-20 Release state: gated experimental vec-i32-without-prefix-helper stdlib gate ### Summary Glagol exp-92 gates the concrete without-prefix helper extension for the staged `std.vec_i32` source-authored facade. The release updates the explicit `std-import-vec_i32/` project, updates the local source-authored `std-layout-local-vec_i32/` fixture, adds focused integration coverage, and extends promotion-gate inventory and sibling Slovo alignment checks for this helper: - `without_prefix` The helper is an ordinary source-authored composition over the existing promoted `std.vec.i32` runtime family and the already staged `std.vec_i32` wrappers for `empty`, `append`, `len`, and `at`, plus the already staged source helpers `starts_with`, `drop`, and `len`. `without_prefix(values,prefix)` removes a matching leading prefix from `values`; returns `values` unchanged for empty, longer, or mismatched prefixes; returns `(empty)` for an exact match; preserves the order of the remaining suffix; leaves both source vectors unchanged; and adds no new parser, checker, runtime, formatter, or LLVM semantics for this release. ### Explicit Deferrals No generic vectors, no vector payload families beyond `(vec i32)`, no automatic standard-library imports, no compiler-loaded std source, no new compiler-known `std.*` runtime names, no new private recursive helper loops, no broader prefix/suffix helper families beyond the current `starts_with`, `without_prefix`, `ends_with`, and `without_suffix` helpers, no slice or view types, no mutable `(vec i32)` local support, no capacity or reserve management, no sorting, mapping, filtering, or iterator APIs, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-91 Release label: `exp-91` Release date: 2026-05-20 Release state: gated experimental vec-i32-without-suffix-helper stdlib gate ### Summary Glagol exp-91 gates the concrete without-suffix helper extension for the staged `std.vec_i32` source-authored facade. The release updates the explicit `std-import-vec_i32/` project, updates the local source-authored `std-layout-local-vec_i32/` fixture, adds focused integration coverage, and extends promotion-gate inventory and sibling Slovo alignment checks for this helper: - `without_suffix` The helper is an ordinary source-authored composition over the existing promoted `std.vec.i32` runtime family and the already staged `std.vec_i32` wrappers for `empty`, `append`, `len`, and `at`, plus the already staged source helpers `ends_with`, `take`, and `len`. `without_suffix(values,suffix)` removes a matching trailing suffix from `values`; returns `values` unchanged for empty, longer, or mismatched suffixes; returns `(empty)` for an exact match; preserves the order of the remaining prefix; leaves both source vectors unchanged; and adds no new parser, checker, runtime, formatter, or LLVM semantics for this release. ### Explicit Deferrals No generic vectors, no vector payload families beyond `(vec i32)`, no automatic standard-library imports, no compiler-loaded std source, no new compiler-known `std.*` runtime names, no new private recursive helper loops, no broader prefix/suffix helper families beyond the current `starts_with`, `ends_with`, and `without_suffix` helpers, no slice or view types, no mutable `(vec i32)` local support, no capacity or reserve management, no sorting, mapping, filtering, or iterator APIs, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-90 Release label: `exp-90` Release date: 2026-05-20 Release state: gated experimental vec-i32-ends-with-helper stdlib gate ### Summary Glagol exp-90 gates the concrete ends-with helper extension for the staged `std.vec_i32` source-authored facade. The release updates the explicit `std-import-vec_i32/` project, updates the local source-authored `std-layout-local-vec_i32/` fixture, adds focused integration coverage, and extends promotion-gate inventory and sibling Slovo alignment checks for this helper: - `ends_with` The helper is an ordinary source-authored composition over the existing promoted `std.vec.i32` runtime family and the already staged `std.vec_i32` wrappers for `empty`, `append`, `len`, and `at`, plus the already staged source helpers `drop` and vec equality. `ends_with(values,suffix)` returns `true` exactly when `values` ends with all elements of `suffix` in order; returns `true` for an empty suffix; returns `false` when `len(suffix) > len(values)`; returns `true` for equal vectors and shorter matching suffixes; returns `false` for mismatched suffixes; leaves both source vectors unchanged; and adds no new parser, checker, runtime, formatter, or LLVM semantics for this release. ### Explicit Deferrals No generic vectors, no vector payload families beyond `(vec i32)`, no automatic standard-library imports, no compiler-loaded std source, no new compiler-known `std.*` runtime names, no new private recursive helper loops, no broader prefix/suffix query families beyond the current `starts_with` and `ends_with` helpers, no slice or view types, no mutable `(vec i32)` local support, no capacity or reserve management, no sorting, mapping, filtering, or iterator APIs, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-89 Release label: `exp-89` Release date: 2026-05-20 Release state: gated experimental vec-i32-starts-with-helper stdlib gate ### Summary Glagol exp-89 gates the concrete starts-with helper extension for the staged `std.vec_i32` source-authored facade. The release updates the explicit `std-import-vec_i32/` project, updates the local source-authored `std-layout-local-vec_i32/` fixture, adds focused integration coverage, and extends promotion-gate inventory and sibling Slovo alignment checks for this helper: - `starts_with` The helper is an ordinary source-authored composition over the existing promoted `std.vec.i32` runtime family and the already staged `std.vec_i32` wrappers for `empty`, `append`, `len`, and `at`, plus the already staged source helpers `take` and vec equality. `starts_with(values,prefix)` returns `true` exactly when `values` begins with all elements of `prefix` in order; returns `true` for an empty prefix; returns `false` when `len(prefix) > len(values)`; returns `true` for equal vectors and shorter matching prefixes; returns `false` for mismatched prefixes; leaves both source vectors unchanged; and adds no new parser, checker, runtime, formatter, or LLVM semantics for this release. ### Explicit Deferrals No generic vectors, no vector payload families beyond `(vec i32)`, no automatic standard-library imports, no compiler-loaded std source, no new compiler-known `std.*` runtime names, no new private recursive helper loops, no broader prefix/suffix query families beyond this single helper, no slice or view types, no mutable `(vec i32)` local support, no capacity or reserve management, no sorting, mapping, filtering, or iterator APIs, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-88 Release label: `exp-88` Release date: 2026-05-20 Release state: gated experimental vec-i32-replace-range-helper stdlib gate ### Summary Glagol exp-88 gates the concrete replace-range helper extension for the staged `std.vec_i32` source-authored facade. The release updates the explicit `std-import-vec_i32/` project, updates the local source-authored `std-layout-local-vec_i32/` fixture, adds focused integration coverage, and extends promotion-gate inventory and sibling Slovo alignment checks for this helper: - `replace_range` The helper is an ordinary source-authored composition over the existing promoted `std.vec.i32` runtime family and the already staged `std.vec_i32` wrappers for `empty`, `append`, `len`, and `at`, plus the already staged source helpers `take`, `drop`, and `concat`. `replace_range(values,start,end_exclusive,replacement)` returns `values` unchanged when `start < 0`, when `end_exclusive <= start`, or when `start >= len(values)`; replaces the half-open range `[start, end_exclusive)` when both bounds are in range; replaces the tail from `start` when `end_exclusive >= len(values)`; preserves the order of both vectors; leaves both source vector values unchanged; and adds no new parser, checker, runtime, formatter, or LLVM semantics for this release. ### Explicit Deferrals No generic vectors, no vector payload families beyond `(vec i32)`, no automatic standard-library imports, no compiler-loaded std source, no new compiler-known `std.*` runtime names, no new private recursive helper loops, no bulk-edit APIs beyond this single contiguous replacement helper, no slice or view types, no mutable `(vec i32)` local support, no capacity or reserve management, no sorting, mapping, filtering, or iterator APIs, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-87 Release label: `exp-87` Release date: 2026-05-20 Release state: gated experimental vec-i32-insert-range-helper stdlib gate ### Summary Glagol exp-87 gates the concrete insert-range helper extension for the staged `std.vec_i32` source-authored facade. The release updates the explicit `std-import-vec_i32/` project, updates the local source-authored `std-layout-local-vec_i32/` fixture, adds focused integration coverage, and extends promotion-gate inventory and sibling Slovo alignment checks for this helper: - `insert_range` The helper is an ordinary source-authored composition over the existing promoted `std.vec.i32` runtime family and the already staged `std.vec_i32` wrappers for `empty`, `append`, `len`, and `at`, plus the already staged source helpers `take`, `drop`, and `concat`. `insert_range(values,position,inserted)` returns `values` unchanged when `position < 0` or `position > len(values)`; inserts `inserted` before the current element when `0 <= position < len(values)`; appends `inserted` when `position == len(values)`; preserves the order of both vectors; leaves both source vector values unchanged; and adds no new parser, checker, runtime, formatter, or LLVM semantics for this release. ### Explicit Deferrals No generic vectors, no vector payload families beyond `(vec i32)`, no automatic standard-library imports, no compiler-loaded std source, no new compiler-known `std.*` runtime names, no new private recursive helper loops, no bulk-edit APIs beyond this single contiguous range insertion helper, no multi-position insertion helpers, no mutable `(vec i32)` local support, no capacity or reserve management, no sorting, mapping, filtering, or iterator APIs, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-86 Release label: `exp-86` Release date: 2026-05-20 Release state: gated experimental vec-i32-remove-range-helper stdlib gate ### Summary Glagol exp-86 gates the concrete remove-range helper extension for the staged `std.vec_i32` source-authored facade. The release updates the explicit `std-import-vec_i32/` project, updates the local source-authored `std-layout-local-vec_i32/` fixture, adds focused integration coverage, and extends promotion-gate inventory and sibling Slovo alignment checks for this helper: - `remove_range` The helper is an ordinary source-authored composition over the existing promoted `std.vec.i32` runtime family and the already staged `std.vec_i32` wrappers for `empty`, `append`, `len`, and `at`, plus the already staged source helpers `take`, `drop`, and `concat`. `remove_range(values,start,end_exclusive)` returns `values` unchanged when `start < 0`, when `end_exclusive <= start`, or when `start >= len(values)`; returns the prefix before `start` when `end_exclusive >= len(values)`; otherwise returns a new vector with the half-open range `[start, end_exclusive)` removed, preserves the order of the remaining elements, and leaves the source vector value unchanged. Glagol adds no new parser, checker, runtime, formatter, or LLVM semantics for this release. ### Explicit Deferrals No generic vectors, no vector payload families beyond `(vec i32)`, no automatic standard-library imports, no compiler-loaded std source, no new compiler-known `std.*` runtime names, no new private recursive helper loops, no bulk-edit APIs beyond this single contiguous removal helper, no mutable `(vec i32)` local support, no capacity or reserve management, no sorting, mapping, filtering, or iterator APIs, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-85 Release label: `exp-85` Release date: 2026-05-20 Release state: gated experimental vec-i32-subvec-helper stdlib gate ### Summary Glagol exp-85 gates the concrete subvector-helper extension for the staged `std.vec_i32` source-authored facade. The release updates the explicit `std-import-vec_i32/` project, updates the local source-authored `std-layout-local-vec_i32/` fixture, adds focused integration coverage, and extends promotion-gate inventory and sibling Slovo alignment checks for this helper: - `subvec` The helper is an ordinary source-authored composition over the existing promoted `std.vec.i32` runtime family and the already staged `std.vec_i32` wrappers for `empty`, `append`, `len`, and `at`, plus the already staged source helpers `drop` and `take`. `subvec(values,start,end_exclusive)` returns the empty vector when `start < 0`, when `end_exclusive <= start`, or when `start >= len(values)`; returns the remaining tail from `start` when `end_exclusive > len(values)`; otherwise returns a copied contiguous subvector `[start, end_exclusive)` with preserved left-to-right order; and leaves the source vector value unchanged. Glagol adds no new parser, checker, runtime, formatter, or LLVM semantics for this release. ### Explicit Deferrals No generic vectors, no vector payload families beyond `(vec i32)`, no automatic standard-library imports, no compiler-loaded std source, no new compiler-known `std.*` runtime names, no new private recursive helper loops, no slice or view types, no mutable `(vec i32)` local support, no capacity or reserve management, no sorting, mapping, filtering, or iterator APIs, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-84 Release label: `exp-84` Release date: 2026-05-20 Release state: gated experimental vec-i32-insert-helper stdlib gate ### Summary Glagol exp-84 gates the concrete insert-helper extension for the staged `std.vec_i32` source-authored facade. The release updates the explicit `std-import-vec_i32/` project, updates the local source-authored `std-layout-local-vec_i32/` fixture, adds focused integration coverage, and extends promotion-gate inventory and sibling Slovo alignment checks for this helper: - `insert_at` The helper is an ordinary source-authored composition over the existing promoted `std.vec.i32` runtime family and the already staged `std.vec_i32` wrappers for `empty`, `append`, `len`, and `at`, plus the already staged source helpers `take`, `drop`, and `concat`. `insert_at(values,position,value)` returns `values` unchanged when `position < 0` or `position > len(values)`; inserts `value` before the current element when `0 <= position < len(values)`; appends `value` when `position == len(values)`; preserves the surrounding order; increases the result length by one for valid insertions; and leaves the source vector value unchanged. Glagol adds no new parser, checker, runtime, formatter, or LLVM semantics for this release. ### Explicit Deferrals No generic vectors, no vector payload families beyond `(vec i32)`, no automatic standard-library imports, no compiler-loaded std source, no new compiler-known `std.*` runtime names, no new private recursive helper loops, no bulk-edit APIs, no multi-index insertion, no mutable `(vec i32)` local support, no capacity or reserve management, no sorting, mapping, filtering, or iterator APIs, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-83 Release label: `exp-83` Release date: 2026-05-20 Release state: gated experimental vec-i32-remove-helper stdlib gate ### Summary Glagol exp-83 gates the concrete remove-helper extension for the staged `std.vec_i32` source-authored facade. The release updates the explicit `std-import-vec_i32/` project, updates the local source-authored `std-layout-local-vec_i32/` fixture, adds focused integration coverage, and extends promotion-gate inventory and sibling Slovo alignment checks for this helper: - `remove_at` The helper is an ordinary source-authored composition over the existing promoted `std.vec.i32` runtime family and the already staged `std.vec_i32` wrappers for `empty`, `append`, `len`, and `at`, plus the already staged source helpers `take`, `drop`, and `concat`. `remove_at(values,position)` returns `values` unchanged when `position < 0` or `position >= len(values)`; otherwise it returns a new vector with the element at `position` removed, preserves the order of the remaining elements, shortens the result length by one, and leaves the source vector value unchanged. Glagol adds no new parser, checker, runtime, formatter, or LLVM semantics for this release. ### Explicit Deferrals No generic vectors, no vector payload families beyond `(vec i32)`, no automatic standard-library imports, no compiler-loaded std source, no new compiler-known `std.*` runtime names, no new private recursive helper loops, no insert helpers, no bulk-edit APIs, no multi-index removal, no mutable `(vec i32)` local support, no capacity or reserve management, no sorting, mapping, filtering, or iterator APIs, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-82 Release label: `exp-82` Release date: 2026-05-20 Release state: gated experimental vec-i32-replace-helper stdlib gate ### Summary Glagol exp-82 gates the concrete replace-helper extension for the staged `std.vec_i32` source-authored facade. The release updates the explicit `std-import-vec_i32/` project, updates the local source-authored `std-layout-local-vec_i32/` fixture, adds focused integration coverage, and extends promotion-gate inventory and sibling Slovo alignment checks for this helper: - `replace_at` The helper is an ordinary source-authored composition over the existing promoted `std.vec.i32` runtime family and the already staged `std.vec_i32` wrappers for `empty`, `append`, `len`, and `at`, plus the already staged source helpers `take`, `drop`, and `concat`. `replace_at(values,position,replacement)` returns `values` unchanged when `position < 0` or `position >= len(values)`; otherwise it returns a new vector with the same length and order except for the replaced slot. Glagol adds no new parser, checker, runtime, formatter, or LLVM semantics for this release. ### Explicit Deferrals No generic vectors, no vector payload families beyond `(vec i32)`, no automatic standard-library imports, no compiler-loaded std source, no new compiler-known `std.*` runtime names, no private mutation loops, no insert or remove helpers, no bulk-edit APIs, no mutable `(vec i32)` local support, no capacity or reserve management, no sorting, mapping, filtering, or iterator APIs, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-81 Release label: `exp-81` Release date: 2026-05-20 Release state: released experimental vec-i32-range-helper stdlib gate ### Summary Glagol exp-81 gates the concrete range-helper extension for the staged `std.vec_i32` source-authored facade. The release updates the explicit `std-import-vec_i32/` project, updates the local source-authored `std-layout-local-vec_i32/` fixture, adds focused integration coverage, and extends promotion-gate inventory and sibling Slovo alignment checks for this helper: - `range` The helper is ordinary source-authored recursion over the existing promoted `std.vec.i32` runtime family and the already staged `std.vec_i32` wrappers for `empty`, `append`, `len`, and `at`. `range(start,end_exclusive)` generates the ascending half-open sequence `[start, start + 1, ..., end_exclusive - 1]`, returns the empty vector when `end_exclusive <= start`, and accepts negative bounds. The recursive generation helper remains private to the fixture source. Glagol adds no new parser, checker, runtime, formatter, or LLVM semantics for this release. ### Explicit Deferrals No generic vectors, no vector payload families beyond `(vec i32)`, no automatic standard-library imports, no compiler-loaded std source, no new compiler-known `std.*` runtime names, no edit helpers, no descending, stepped, or inclusive range variants, no mutable `(vec i32)` local support, no capacity or reserve management, no sorting, mapping, filtering, or iterator APIs, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-80 Release label: `exp-80` Release date: 2026-05-20 Release state: released experimental vec-i32-generated-constructor-helper stdlib gate ### Summary Glagol exp-80 gates the concrete generated-constructor-helper extension for the staged `std.vec_i32` source-authored facade. The release updates the explicit `std-import-vec_i32/` project, updates the local source-authored `std-layout-local-vec_i32/` fixture, adds focused integration coverage, and extends promotion-gate inventory and sibling Slovo alignment checks for these helpers: - `repeat` - `range_from_zero` The helpers are ordinary source-authored recursion over the existing promoted `std.vec.i32` runtime family and the already staged `std.vec_i32` wrappers for `empty`, `append`, `len`, and `at`. `repeat(value,count)` returns the empty vector for `count <= 0`, and `range_from_zero(count)` generates the ascending half-open sequence `[0, 1, ..., count - 1]`, returning the empty vector for `count <= 0`. The recursive generation helpers remain private to the fixture source. Glagol adds no new parser, checker, runtime, formatter, or LLVM semantics for this release. ### Explicit Deferrals No generic vectors, no vector payload families beyond `(vec i32)`, no automatic standard-library imports, no compiler-loaded std source, no new compiler-known `std.*` runtime names, no edit helpers, no public `range` helper, no descending, stepped, or inclusive range variants, no mutable `(vec i32)` local support, no capacity or reserve management, no sorting, mapping, filtering, or iterator APIs, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-79 Release label: `exp-79` Release date: 2026-05-20 Release state: released experimental vec-i32-transform-helper stdlib gate ### Summary Glagol exp-79 gates the concrete transform-helper extension for the staged `std.vec_i32` source-authored facade. The release updates the explicit `std-import-vec_i32/` project, updates the local source-authored `std-layout-local-vec_i32/` fixture, adds focused integration coverage, and extends promotion-gate inventory and sibling Slovo alignment checks for these helpers: - `concat` - `take` - `drop` - `reverse` The helpers are ordinary source-authored recursion over the existing promoted `std.vec.i32` runtime family and the already staged `std.vec_i32` wrappers for `empty`, `append`, `len`, and `at`. Glagol adds no new parser, checker, runtime, formatter, or LLVM semantics for this release. ### Explicit Deferrals No generic vectors, no vector payload families beyond `(vec i32)`, no automatic standard-library imports, no compiler-loaded std source, no new compiler-known `std.*` runtime names, no mutable `(vec i32)` local support, no capacity or reserve management, no sorting, mapping, filtering, or iterator APIs, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-78 Release label: `exp-78` Release date: 2026-05-20 Release state: released experimental cli-local-source-facade stdlib gate ### Summary Glagol exp-78 gates the Glagol-side local source-authored `cli` facade that mirrors the existing staged `std.cli` helper surface without widening it. The release adds `examples/projects/std-layout-local-cli/` with explicit local `cli.slo`, `process.slo`, and `string.slo` modules plus the matching `main.slo` consumer, adds focused integration coverage, and extends promotion-gate inventory/alignment checks for these helpers: - `arg_text_result` - `arg_i32_result` - `arg_i32_or_zero` - `arg_i32_or` - `arg_i64_result` - `arg_i64_or_zero` - `arg_i64_or` - `arg_f64_result` - `arg_f64_or_zero` - `arg_f64_or` - `arg_bool_result` - `arg_bool_or_false` - `arg_bool_or` The local fixture stays source-authored and explicit: `main.slo` imports local `cli`, `cli.slo` imports local `process` and `string`, `process.slo` wraps only the existing promoted `std.process.arg_result`, and `string.slo` wraps only the existing promoted concrete parse-result helpers. Glagol adds no new parser, checker, runtime, formatter, or LLVM semantics for this release. ### Explicit Deferrals No widened `std.cli` API, no automatic standard-library imports, no compiler- loaded std source, no automatic standard-library search semantics, no new compiler-known `std.*` runtime names, no process spawning, exit/status control, no current-directory APIs, no signal handling, no shell parsing, no subcommands, no flag or option frameworks, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-77 Release label: `exp-77` Release date: 2026-05-20 Release state: released experimental vec-i32-option-query-helper stdlib gate ### Summary Glagol exp-77 extends the concrete `(vec i32)` source-authored collection facade in the staged `std.vec_i32` module with option-returning query helpers. The release updates the explicit `std-import-vec_i32/` project, updates the local source-authored `std-layout-local-vec_i32/` fixture, adds focused integration coverage, and extends promotion-gate inventory and sibling Slovo alignment checks for these helpers: - `index_option` - `first_option` - `last_option` - `index_of_option` - `last_index_of_option` The helpers are ordinary source wrappers and loops over the existing promoted `std.vec.i32` runtime family plus the existing `(option i32)` surface. Glagol adds no new parser, checker, runtime, or LLVM semantics for this release. ### Explicit Deferrals No generic vectors, no vector payload families beyond `(vec i32)`, no option payload families beyond `(option i32)`, no automatic standard-library imports, no compiler-loaded std source, no new compiler-known `std.*` runtime names, no capacity or reserve management, no sorting, mapping, filtering, or iterator APIs, no mutating collection APIs, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-76 Release label: `exp-76` Release date: 2026-05-20 Release state: released experimental vec-i32-source-helper stdlib gate ### Summary Glagol exp-76 gates a concrete `(vec i32)` source-authored collection facade in the staged `std.vec_i32` module. The release adds the explicit `std-import-vec_i32/` project, adds the local source-authored `std-layout-local-vec_i32/` fixture, adds focused integration coverage, and extends promotion-gate inventory and sibling Slovo alignment checks for these helpers: - `empty` - `append` - `len` - `at` - `singleton` - `append2` - `append3` - `pair` - `triple` - `is_empty` - `index_or` - `first_or` - `last_or` - `contains` - `sum` The helpers are ordinary source wrappers and loops over the existing promoted `std.vec.i32` runtime family. Glagol adds no new parser, checker, runtime, or LLVM semantics for this release. ### Explicit Deferrals No generic vectors, no vector payload families beyond `(vec i32)`, no automatic standard-library imports, no compiler-loaded std source, no new compiler-known `std.*` runtime names, no capacity or reserve management, no sorting, mapping, filtering, or iterator APIs, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-75 Release label: `exp-75` Release date: 2026-05-20 Release state: released experimental option-constructor stdlib gate ### Summary Glagol exp-75 gates source-authored concrete option constructors in the staged `std.option` facade. The release expands the explicit `std-import-option/` project, updates the local source-authored `std-layout-local-option/` fixture, and extends focused integration coverage plus promotion-gate inventory/alignment checks for these helpers: - `some_i32` - `none_i32` The helpers are ordinary source wrappers over the existing `some` and `none` forms for the currently promoted `(option i32)` family. Glagol adds no new parser, checker, runtime, or LLVM semantics for this release. ### Explicit Deferrals No generic option helpers, no new option payload families, no automatic standard-library imports, no compiler-loaded std source, no new compiler-known `std.*` runtime names, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-74 Release label: `exp-74` Release date: 2026-05-20 Release state: released experimental result-constructor stdlib gate ### Summary Glagol exp-74 gates source-authored concrete result constructors in the staged `std.result` facade. The release expands the explicit `std-import-result/` project, updates the local source-authored `std-layout-local-result/` fixture, and extends focused integration coverage plus promotion-gate inventory/alignment checks for these helpers: - `ok_i32` - `err_i32` - `ok_i64` - `err_i64` - `ok_string` - `err_string` - `ok_f64` - `err_f64` - `ok_bool` - `err_bool` The helpers are ordinary source wrappers over the existing `ok` and `err` forms for the currently promoted concrete result families. Glagol adds no new parser, checker, runtime, or LLVM semantics for this release. ### Explicit Deferrals No generic result helpers, no new result payload families, no richer error ADTs, no automatic standard-library imports, no compiler-loaded std source, no new compiler-known `std.*` runtime names, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-73 Release label: `exp-73` Release date: 2026-05-20 Release state: released experimental io-value-helper stdlib gate ### Summary Glagol exp-73 gates source-authored value-returning print helpers in the staged `std.io` facade. The release expands the explicit `std-import-io/` project, adds the local source-authored `std-layout-local-io/` fixture plus focused integration coverage, and extends promotion-gate inventory/alignment checks for these helpers: - `print_i32_value` - `print_i64_value` - `print_f64_value` - `print_string_value` - `print_bool_value` The helpers are ordinary source wrappers over the existing promoted print runtime calls. Glagol adds no new parser, checker, runtime, or LLVM semantics for this release. ### Explicit Deferrals No automatic standard-library imports, no compiler-loaded std source, no stderr facade helpers, no stdin facade helpers, no line iteration, no prompt APIs, no terminal control, no binary or streaming IO, no async IO, no new compiler-known `std.*` runtime names, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-72 Release label: `exp-72` Release date: 2026-05-20 Release state: released experimental cli-custom-fallback stdlib gate ### Summary Glagol exp-72 gates source-authored typed CLI argument custom-fallback helpers in the staged `std.cli` facade. The release expands the explicit `std-import-cli/` project, adds focused integration coverage, and extends promotion-gate inventory/alignment checks for these helpers: - `arg_i32_or` - `arg_i64_or` - `arg_f64_or` - `arg_bool_or` The helpers are ordinary source wrappers over the existing argument lookup and concrete parse result families. Glagol adds no new parser, checker, runtime, or LLVM semantics for this release. ### Explicit Deferrals No automatic standard-library imports, no compiler-loaded std source, no process spawning, no exit/status control, no current-directory APIs, no signal handling, no shell parsing, no subcommands, no richer CLI framework APIs, no generic configuration helpers, no new compiler-known `std.*` runtime names, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-71 Release label: `exp-71` Release date: 2026-05-20 Release state: released experimental process-custom-fallback stdlib gate ### Summary Glagol exp-71 gates source-authored typed process argument custom-fallback helpers in the staged `std.process` facade. The release expands the local source-authored process fixture at `examples/projects/std-layout-local-process/` with a local `string.slo` parse wrapper module, expands the explicit `std-import-process/` project, adds focused integration coverage, and extends promotion-gate inventory/alignment checks for these helpers: - `arg_i32_or` - `arg_i64_or` - `arg_f64_or` - `arg_bool_or` The helpers are ordinary source wrappers over the existing argument lookup and concrete parse result families. Glagol adds no new parser, checker, runtime, or LLVM semantics for this release. ### Explicit Deferrals No automatic standard-library imports, no compiler-loaded std source, no process spawning, no exit/status control, no current-directory APIs, no signal handling, no shell parsing, no subcommands, no richer CLI framework APIs, no generic configuration helpers, no new compiler-known `std.*` runtime names, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-70 Release label: `exp-70` Release date: 2026-05-20 Release state: released experimental fs-custom-fallback stdlib gate ### Summary Glagol exp-70 gates source-authored typed filesystem read custom-fallback helpers in the staged `std.fs` facade. The release expands the local source-authored fs fixture at `examples/projects/std-layout-local-fs/` with a local `string.slo` parse wrapper module, expands the explicit `std-import-fs/` project, adds focused integration coverage, and extends promotion-gate inventory/alignment checks for these helpers: - `read_i32_or` - `read_i64_or` - `read_f64_or` - `read_bool_or` The helpers are ordinary source wrappers over the existing text-read and concrete parse result families. Glagol adds no new parser, checker, runtime, or LLVM semantics for this release. ### Explicit Deferrals No automatic standard-library imports, no compiler-loaded std source, no binary file APIs, no directory traversal, no streaming file IO, no async file IO, no typed file writes, no rich host errors, no new compiler-known `std.*` runtime names, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-69 Release label: `exp-69` Release date: 2026-05-20 Release state: released experimental env-custom-fallback stdlib gate ### Summary Glagol exp-69 gates source-authored typed environment parse custom-fallback helpers in the staged `std.env` facade. The release expands the local source-authored env fixture at `examples/projects/std-layout-local-env/`, expands the explicit `std-import-env/` project, adds deterministic present/missing/invalid environment setup to focused integration coverage, and extends promotion-gate inventory/alignment checks for these helpers: - `get_i32_or` - `get_i64_or` - `get_f64_or` - `get_bool_or` The helpers are ordinary source wrappers over the existing environment lookup and concrete parse result families. Glagol adds no new parser, checker, runtime, or LLVM semantics for this release. ### Explicit Deferrals No automatic standard-library imports, no compiler-loaded std source, no generic configuration helpers, no environment mutation, no environment enumeration, no environment writes, no rich host errors, no new compiler-known `std.*` runtime names, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-68 Release label: `exp-68` Release date: 2026-05-20 Release state: released experimental string-custom-fallback stdlib gate ### Summary Glagol exp-68 gates source-authored typed string parse custom-fallback helpers in the staged `std.string` facade. The release expands the local source-authored string fixture at `examples/projects/std-layout-local-string/`, expands the explicit `std-import-string/` project, adds focused integration coverage, and extends promotion-gate inventory/alignment checks for these helpers: - `parse_i32_or` - `parse_i64_or` - `parse_f64_or` - `parse_bool_or` The helpers are ordinary source wrappers over the existing concrete parse result families. Glagol adds no new parser, checker, runtime, or LLVM semantics for this release. ### Explicit Deferrals No automatic standard-library imports, no compiler-loaded std source, no generic parse helpers, no whitespace trimming, no case-insensitive bool parsing, no rich parse errors, no new compiler-known `std.*` runtime names, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-67 Release label: `exp-67` Release date: 2026-05-20 Release state: released experimental process-typed stdlib gate ### Summary Glagol exp-67 gates source-authored typed process argument helpers in the staged `std.process` facade. The release expands the local source-authored process fixture at `examples/projects/std-layout-local-process/` with a local `string.slo` parse wrapper module, expands the explicit `std-import-process/` project, adds focused integration coverage, and extends promotion-gate inventory/alignment checks for these helpers: - `arg_i32_result` - `arg_i32_or_zero` - `arg_i64_result` - `arg_i64_or_zero` - `arg_f64_result` - `arg_f64_or_zero` - `arg_bool_result` - `arg_bool_or_false` The helpers are ordinary source wrappers over the existing argument lookup and concrete parse result families. Glagol adds no new parser, checker, runtime, or LLVM semantics for this release. ### Explicit Deferrals No automatic standard-library imports, no compiler-loaded std source, no process spawning, no exit/status control, no current-directory APIs, no signal handling, no shell parsing, no subcommands, no richer CLI framework APIs, no rich host errors, no new compiler-known `std.*` runtime names, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-66 Release label: `exp-66` Release date: 2026-05-20 Release state: released experimental fs-typed-read stdlib gate ### Summary Glagol exp-66 gates source-authored typed filesystem read helpers in the staged `std.fs` facade. The release expands the local source-authored fs fixture at `examples/projects/std-layout-local-fs/` with a local `string.slo` parse wrapper module, expands the explicit `std-import-fs/` project, adds focused integration coverage, and extends promotion-gate inventory/alignment checks for these helpers: - `read_i32_result` - `read_i32_or_zero` - `read_i64_result` - `read_i64_or_zero` - `read_f64_result` - `read_f64_or_zero` - `read_bool_result` - `read_bool_or_false` The helpers are ordinary source wrappers over the existing text-read and concrete parse result families. Glagol adds no new parser, checker, runtime, or LLVM semantics for this release. ### Explicit Deferrals No automatic standard-library imports, no compiler-loaded std source, no binary file APIs, no directory traversal, no streaming file IO, no async file IO, no typed file writes, no rich host errors, no new compiler-known `std.*` runtime names, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-65 Release label: `exp-65` Release date: 2026-05-20 Release state: released experimental env-typed stdlib gate ### Summary Glagol exp-65 gates source-authored typed environment helpers in the staged `std.env` facade. The release expands the local source-authored env fixture at `examples/projects/std-layout-local-env/` with a local `string.slo` parse wrapper module, expands the explicit `std-import-env/` project, adds deterministic present/missing/invalid environment setup to focused integration coverage, and extends promotion-gate inventory/alignment checks for these helpers: - `get_i32_result` - `get_i32_or_zero` - `get_i64_result` - `get_i64_or_zero` - `get_f64_result` - `get_f64_or_zero` - `get_bool_result` - `get_bool_or_false` The helpers are ordinary source wrappers over the existing environment lookup and concrete parse result families. Glagol adds no new parser, checker, runtime, or LLVM semantics for this release. ### Explicit Deferrals No automatic standard-library imports, no compiler-loaded std source, no environment mutation, no environment enumeration, no environment writes, no generic configuration helpers, no rich host errors, no new compiler-known `std.*` runtime names, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-64 Release label: `exp-64` Release date: 2026-05-20 Release state: released experimental num-fallback stdlib gate ### Summary Glagol exp-64 gates source-authored checked conversion fallback helpers in the staged `std.num` facade. The release adds a local source-authored num fixture at `examples/projects/std-layout-local-num/`, expands the explicit `std-import-num/` project, adds focused integration coverage, and extends promotion-gate inventory/alignment checks for these helpers: - `i64_to_i32_or` - `f64_to_i32_or` - `f64_to_i64_or` The helpers are ordinary source wrappers over the existing checked numeric conversion result families. Glagol adds no new parser, checker, runtime, or LLVM semantics for this release. ### Explicit Deferrals No automatic standard-library imports, no compiler-loaded std source, no unchecked narrowing conversions, no saturating conversions, no generic numeric traits, no new compiler-known `std.*` runtime names, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-63 Release label: `exp-63` Release date: 2026-05-20 Release state: released experimental fs-fallback stdlib gate ### Summary Glagol exp-63 gates source-authored fallback/status helpers in the staged `std.fs` facade. The release expands the local source-authored fs fixture at `examples/projects/std-layout-local-fs/`, expands the explicit `std-import-fs/` project, adds focused integration coverage, and extends promotion-gate inventory/alignment checks for these helpers: - `read_text_or` - `write_text_ok` The helpers are ordinary source wrappers over the existing text filesystem result families. Glagol adds no new parser, checker, runtime, or LLVM semantics for this release. ### Explicit Deferrals No automatic standard-library imports, no compiler-loaded std source, no binary file APIs, no directory traversal, no streaming file IO, no async file IO, no rich host errors, no new compiler-known `std.*` runtime names, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-62 Release label: `exp-62` Release date: 2026-05-20 Release state: released experimental env-fallback stdlib gate ### Summary Glagol exp-62 gates source-authored fallback helpers in the staged `std.env` facade. The release expands the local source-authored env fixture at `examples/projects/std-layout-local-env/`, expands the explicit `std-import-env/` project, adds deterministic present/missing environment setup to focused integration coverage, and extends promotion-gate inventory/alignment checks for these helpers: - `has` - `get_or` The helpers are ordinary source wrappers over the existing environment lookup result family. Glagol adds no new parser, checker, runtime, or LLVM semantics for this release. ### Explicit Deferrals No automatic standard-library imports, no compiler-loaded std source, no environment mutation, no environment enumeration, no platform/configuration APIs, no rich host errors, no new compiler-known `std.*` runtime names, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-61 Release label: `exp-61` Release date: 2026-05-20 Release state: released experimental process-fallback stdlib gate ### Summary Glagol exp-61 gates source-authored fallback helpers in the staged `std.process` facade. The release adds a local source-authored process fixture at `examples/projects/std-layout-local-process/`, expands the explicit `std-import-process/` project, adds focused integration coverage, and extends promotion-gate inventory/alignment checks for these helpers: - `arg_or` - `arg_or_empty` The helpers are ordinary source wrappers over the existing process argument result family. Glagol adds no new parser, checker, runtime, or LLVM semantics for this release. ### Explicit Deferrals No automatic standard-library imports, no compiler-loaded std source, no shell parsing, no option/flag parsing, no subcommands, no spawning, no exit/status control, no rich host errors, no new compiler-known `std.*` runtime names, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-60 Release label: `exp-60` Release date: 2026-05-20 Release state: released experimental string-fallback stdlib gate ### Summary Glagol exp-60 gates source-authored string parse fallback helpers in the staged `std.string` facade. The release adds a local source-authored string fixture at `examples/projects/std-layout-local-string/`, expands the explicit `std-import-string/` project, adds focused integration coverage, and extends promotion-gate inventory/alignment checks for these helpers: - `parse_i32_or_zero` - `parse_i64_or_zero` - `parse_f64_or_zero` - `parse_bool_or_false` The helpers are ordinary source wrappers over the existing concrete parse result families. Glagol adds no new parser, checker, runtime, or LLVM semantics for this release. ### Explicit Deferrals No automatic standard-library imports, no compiler-loaded std source, no generic parse helpers, no whitespace trimming, no case-insensitive bool parsing, no rich parse errors, no new compiler-known `std.*` runtime names, no stable ABI/layout guarantees, and no beta maturity are included. ## exp-59 Release label: `exp-59` Release date: 2026-05-20 Release state: released experimental hosted-build optimization and benchmark publication gate ### Summary Glagol exp-59 tightens hosted executable builds and refreshes the publication process around the benchmark evidence. The release keeps the language surface unchanged, but it now builds hosted executables through `clang -O2`, lowers immutable numeric locals directly as SSA values where the current checker/runtime model allows it, updates the benchmark methodology/writeups, and adds repo-local PDF rendering scripts for the current whitepaper and compiler manifest. ### Explicit Deferrals No general optimizer pass pipeline, no benchmark thresholds, no cross-machine performance claims, no stable ABI/layout guarantees, no broad SSA lowering for every value family, and no beta maturity are included. ## exp-58 Release label: `exp-58` Release date: 2026-05-19 Release state: released experimental boolean logic compiler gate ### Summary Glagol exp-58 gates `and`, `or`, and `not` as boolean logic forms. The release adds `examples/boolean-logic.slo`, focused integration coverage, promotion-gate coverage, and sibling Slovo fixture alignment. `and` and `or` lower through existing `if` semantics and short-circuit. ### Explicit Deferrals No truthiness, variadic boolean operators, pattern guards, macro expansion, stable ABI/layout, optimizer guarantees, benchmark thresholds, or beta maturity are included. ## exp-57 Release label: `exp-57` Release date: 2026-05-19 Release state: released experimental integer bitwise compiler/stdlib gate ### Summary Glagol exp-57 gates `bit_and`, `bit_or`, and `bit_xor` for same-width `i32` and `i64` operands. The release adds `examples/integer-bitwise.slo`, focused integration coverage, promotion-gate coverage, and expanded `std.math` project coverage for `bit_and_i32`, `bit_or_i32`, `bit_xor_i32`, `bit_and_i64`, `bit_or_i64`, and `bit_xor_i64`. ### Explicit Deferrals No shifts, bit-not, unsigned arithmetic, bit-width-specific integer families, floating-point bitwise operations, generic math, mixed numeric arithmetic, stable ABI/layout, optimizer guarantees, benchmark thresholds, or beta maturity are included. ## exp-56 Release label: `exp-56` Release date: 2026-05-19 Release state: released experimental integer remainder compiler/stdlib gate ### Summary Glagol exp-56 gates `%` as signed integer remainder for same-width `i32` and `i64` operands. The release adds `examples/integer-remainder.slo`, focused integration coverage, promotion-gate coverage, and expanded `std.math` project coverage for `rem_i32`, `is_even_i32`, `is_odd_i32`, `rem_i64`, `is_even_i64`, and `is_odd_i64`. ### Explicit Deferrals No floating-point remainder, Euclidean modulo, unsigned arithmetic, bit operations, generic math, mixed numeric arithmetic, stable ABI/layout, optimizer guarantees, benchmark thresholds, or beta maturity are included. ## exp-55 Release label: `exp-55` Release date: 2026-05-19 Release state: released experimental f64/bool result source-flow gate ### Summary Glagol exp-55 gates source constructors and source `match` payload bindings for `(result f64 i32)` and `(result bool i32)`. The release adds `examples/result-f64-bool-match.slo`, focused integration coverage, and updated `std.cli` coverage. The CLI facade now propagates missing argument indexes as `err 1` for `f64` and `bool` helpers instead of using trap-based argument lookup. ### Explicit Deferrals No generic result types, result payload families beyond the already promoted concrete families, generic `map`/`and_then`, exception handling, automatic standard-library imports, stable ABI/layout/ownership, optimizer guarantees, benchmark thresholds, or beta maturity are included. ## exp-54 Release label: `exp-54` Release date: 2026-05-19 Release state: released experimental typed CLI facade gate ### Summary Glagol exp-54 gates the expanded `std.cli` source facade with typed argument parse helpers for `i64`, `f64`, and `bool`. The release updates `examples/projects/std-import-cli/`, focused integration coverage, and promotion-gate coverage. The deterministic fixture checks missing-index result propagation for the current source-supported `string`, `i32`, and `i64` result families, while keeping `f64` and `bool` parse-result helpers compile-gated through the explicit import surface. ### Explicit Deferrals No automatic standard-library imports, `std.slo` aggregator, package registry behavior, lockfiles, package std dependencies, new compiler-known runtime names, `err f64 i32` or `err bool i32` source constructors, source `match` over `(result f64 i32)` or `(result bool i32)`, shell parsing, option/flag parsing, subcommands, environment-backed configuration, stable CLI framework APIs, stable ABI/layout/ownership, optimizer guarantees, benchmark thresholds, or beta maturity are included. ## exp-53 Release label: `exp-53` Release date: 2026-05-19 Release state: released experimental CLI-facade standard-source search gate ### Summary Glagol exp-53 gates explicit project-mode source search for the staged standard CLI facade module: `std.cli`. The release adds `examples/projects/std-import-cli/`, focused integration coverage, and promotion-gate coverage. The fixture imports sibling Slovo standard source without carrying a local copied module, and the facade exercises transitive standard-source imports through `std.process` and `std.string`. ### Explicit Deferrals No automatic standard-library imports, `std.slo` aggregator, package registry behavior, lockfiles, package std dependencies, new compiler-known runtime names, shell parsing, option/flag parsing, subcommands, environment-backed configuration, stable CLI framework APIs, stable ABI/layout/ownership, optimizer guarantees, benchmark thresholds, or beta maturity are included. ## exp-52 Release label: `exp-52` Release date: 2026-05-19 Release state: released experimental process-facade standard-source search gate ### Summary Glagol exp-52 gates explicit project-mode source search for the staged standard process facade module: `std.process`. The release adds `examples/projects/std-import-process/`, focused integration coverage, and promotion-gate coverage. The fixture imports sibling Slovo standard source without carrying a local copied module. ### Explicit Deferrals No automatic standard-library imports, `std.slo` aggregator, package registry behavior, lockfiles, package std dependencies, new compiler-known process runtime names, process spawning, exit/status control, current-directory APIs, signal handling, stable ABI/layout/ownership, optimizer guarantees, benchmark thresholds, or beta maturity are included. ## exp-51 Release label: `exp-51` Release date: 2026-05-19 Release state: released experimental standard-library path-list discovery gate ### Summary Glagol exp-51 interprets `SLOVO_STD_PATH` as an ordered OS path list. The standard-source resolver checks listed roots in order and resolves the first root containing the requested module file. This supports layered standard-library development: an override root can contain only the module under test, while a later root can provide the rest of the staged standard library. ### Explicit Deferrals No automatic standard-library imports, `std.slo` aggregator, package registry behavior, lockfiles, package std dependencies, semantic version solving, stable package manager behavior, broad standard-library APIs, stable ABI/layout/ownership, optimizer guarantees, benchmark thresholds, or beta maturity are included. ## exp-50 Release label: `exp-50` Release date: 2026-05-19 Release state: released experimental installed standard-library discovery gate ### Summary Glagol exp-50 gates installed-toolchain discovery for explicit standard-source imports. A copied `glagol` binary can find staged Slovo standard-library modules under executable-relative `../share/slovo/std` without `SLOVO_STD_PATH` or a sibling checkout. The resolver now checks candidates per requested module file, so an earlier partial std root does not mask a later root containing the module. ### Explicit Deferrals No automatic standard-library imports, `std.slo` aggregator, package registry behavior, lockfiles, package std dependencies, stable install layout guarantees beyond this alpha candidate, new compiler-known runtime names, broad standard-library APIs, stable ABI/layout/ownership, optimizer guarantees, benchmark thresholds, or beta maturity are included. ## exp-49 Release label: `exp-49` Release date: 2026-05-19 Release state: released experimental io-facade standard-source search gate ### Summary Glagol exp-49 gates explicit project-mode source search for the staged standard IO facade module: `std.io`. The release adds `examples/projects/std-import-io/`, focused integration coverage, and promotion-gate coverage. The fixture imports sibling Slovo standard source without carrying a local copied module. ### Explicit Deferrals No automatic standard-library imports, `std.slo` aggregator, package registry behavior, installed stdlib paths, new compiler-known IO names, formatted output APIs, stream abstractions, async IO, stable ABI/layout/ownership, optimizer guarantees, benchmark thresholds, or beta maturity are included. ## exp-48 Release label: `exp-48` Release date: 2026-05-19 Release state: released experimental core-facade standard-source search gate ### Summary Glagol exp-48 gates explicit project-mode source search for the staged standard core facade modules: `std.string` and `std.num`. The release adds `examples/projects/std-import-string/` and `examples/projects/std-import-num/`, focused integration coverage, and promotion-gate coverage. Each fixture imports sibling Slovo standard source without carrying a local copied module. ### Explicit Deferrals No automatic standard-library imports, `std.slo` aggregator, package registry behavior, installed stdlib paths, generic parse/format APIs, broad numeric casts, stable ABI/layout/ownership, optimizer guarantees, benchmark thresholds, or beta maturity are included. ## exp-47 Release label: `exp-47` Release date: 2026-05-19 Release state: released experimental host-facade standard-source search gate ### Summary Glagol exp-47 gates explicit project-mode source search for the staged standard host facade modules: `std.time`, `std.random`, `std.env`, and `std.fs`. The release adds `examples/projects/std-import-time/`, `examples/projects/std-import-random/`, `examples/projects/std-import-env/`, and `examples/projects/std-import-fs/`, focused integration coverage, and promotion-gate coverage. Each fixture imports sibling Slovo standard source without carrying a local copied module. ### Explicit Deferrals No automatic standard-library imports, `std.slo` aggregator, workspace dependency syntax for std, package registry behavior, installed stdlib paths, broad host APIs, stable ABI/layout/ownership, optimizer guarantees, benchmark thresholds, or beta maturity are included. ## exp-46 Release label: `exp-46` Release date: 2026-05-19 Release state: released experimental workspace standard-source search gate ### Summary Glagol exp-46 implements explicit standard-library source search inside workspace packages. Workspace package modules can import `std.` source modules using the same `SLOVO_STD_PATH` or `lib/std` discovery model as project mode. The release adds `examples/workspaces/std-import-option/`, focused integration coverage, and promotion-gate coverage. ### Explicit Deferrals No automatic standard-library imports, workspace dependency syntax for std, package registry behavior, installed toolchain stdlib paths, `std.slo` aggregator, generic option helpers, broad stdlib APIs, stable ABI/layout/ownership, optimizer guarantees, benchmark thresholds, or beta maturity are included. ## exp-45 Release label: `exp-45` Release date: 2026-05-19 Release state: released experimental result/option standard-source search gate ### Summary Glagol exp-45 gates the exp-44 source-search resolver for two additional staged standard modules: `std.result` and `std.option`. The release adds `examples/projects/std-import-result/` and `examples/projects/std-import-option/`, focused integration coverage, and promotion-gate coverage. Both fixtures import repo-root Slovo standard source without carrying local `result.slo` or `option.slo` copies. ### Explicit Deferrals No automatic standard-library imports, workspace/package `std` imports, package registry behavior, `std.slo` aggregator, glob imports, aliases, qualified member access, generic result helpers, generic option helpers, broad stdlib APIs, stable ABI/layout/ownership, optimizer guarantees, benchmark thresholds, or beta maturity are included. ## exp-44 Release label: `exp-44` Release date: 2026-05-19 Release state: released experimental standard-library source-search gate ### Summary Glagol exp-44 implements project-mode source search for explicit `std.` imports, starting with `std.math`. A project can now write `(import std.math (...))` and the compiler loads sibling Slovo `std/math.slo` source instead of requiring a local copied `math.slo`. The release adds `examples/projects/std-import-math/`, focused integration coverage, and promotion-gate coverage. The standard-library root is discovered through `SLOVO_STD_PATH` or a `lib/std` checkout. ### Explicit Deferrals No automatic standard-library imports, workspace/package `std` imports, package registry behavior, `std.slo` aggregator, glob imports, aliases, qualified member access, compiler-known `std.*` runtime names, broad stdlib APIs, stable ABI/layout/ownership, optimizer guarantees, benchmark thresholds, or beta maturity are included. ## exp-43 Release label: `exp-43` Release date: 2026-05-19 Release state: released experimental technical whitepaper and design-skill gates ### Summary Glagol exp-43 publishes `docs/GLAGOL_WHITEPAPER.md`, generated PDF publication artifacts, a concise compiler manifest, and a repository-local beta compiler-design skill under `.llm/skills/`. ### Explicit Deferrals No parser behavior, checker behavior, backend behavior, runtime APIs, compiler-known `std.*` names, automatic standard-library imports, stable ABI/layout/ownership, optimizer guarantees, benchmark thresholds, cross-machine performance claims, package registry behavior, or beta maturity are included. ## exp-42 Release label: `exp-42` Release date: 2026-05-19 Release state: released experimental hot-loop benchmark mode gates ### Summary Glagol exp-42 separates two benchmark meanings in the shared runner: `cold-process` for one normal startup-inclusive run, and `hot-loop` for a larger runtime-supplied loop count with total time plus normalized median time for the base loop count. The benchmark metadata now records hot-loop counts and checksums. The Slovo benchmark fixtures accept the runner loop count through process arguments with stdin fallback, so Slovo can participate in hot-loop mode. ### Explicit Deferrals No language semantics, compiler optimizations, high-resolution Slovo timing APIs, stable benchmark thresholds, cross-machine performance claims, stable ABI/layout/ownership, package registry behavior, hot-runtime benchmark daemon, or beta maturity are included. ## exp-41 Release label: `exp-41` Release date: 2026-05-19 Release state: released experimental Lisp benchmark comparison gates ### Summary Glagol exp-41 extends the local benchmark suite with Common Lisp/SBCL source slots beside the existing Clojure slots. The benchmark suite includes `math-loop`, `branch-loop`, and `parse-loop` scaffolds, each with Slovo, C, Rust, Python, Clojure, and Common Lisp/SBCL source slots where the local toolchain is available. The shared runner detects SBCL through `sbcl`, `SBCL`, or `--sbcl`. Benchmark timing remains cold-process local-machine evidence only: Clojure timings include JVM and Clojure startup, while Common Lisp timings include SBCL script startup. ### Explicit Deferrals No language semantics, compiler optimizations, stable benchmark thresholds, cross-machine performance claims, stable ABI/layout/ownership, package registry behavior, hot-runtime benchmark daemon, or beta maturity are included. ## exp-40 Release label: `exp-40` Release date: 2026-05-19 Release state: released experimental benchmark-suite and license gates ### Summary Glagol exp-40 adds a broader local benchmark suite and project license files. The benchmark suite includes `math-loop`, `branch-loop`, and `parse-loop` scaffolds, each with Slovo, C, Rust, Python, and Clojure source slots where the local toolchain is available. The shared runner validates deterministic checksums, skips missing toolchains, and reports local-machine timing comparisons only. Clojure is detected through `clojure`, `CLOJURE`, or `CLOJURE_JAR`. Glagol is documented and licensed as `MIT OR Apache-2.0`, matching the Cargo package metadata. Alpha/beta release criteria are recorded in `.llm/`. ### Explicit Deferrals No language semantics, compiler optimizations, stable benchmark thresholds, cross-machine performance claims, stable ABI/layout/ownership, package registry behavior, or beta maturity are included. ## exp-39 Release label: `exp-39` Release date: 2026-05-19 Release state: released experimental math-helper and benchmark-scaffold gates ### Summary Glagol exp-39 implements Standard Math Extensions And Benchmark Scaffold Alpha on the Glagol side as fixture, documentation, promotion-gate coverage, and a local benchmark scaffold. It extends `examples/projects/std-layout-local-math/` so an ordinary project explicitly imports local `math.slo` helpers for `abs`, `neg`, `min`, `max`, `clamp`, `square`, `cube`, `is_zero`, `is_positive`, `is_negative`, and inclusive `in_range` across `i32`, `i64`, and finite `f64`. It also adds `benchmarks/math-loop/`, with Slovo, C, Rust, and Python implementations plus a runner for local-machine timing comparisons. The runner supplies the loop count through stdin, validates a shared checksum, skips missing toolchains where possible, and reports timing data only as local evidence. ### Explicit Deferrals No new compiler-known `std.*` names, automatic std import/search path, compiler-loaded std source, new numeric primitives, modulo, trigonometry/sqrt/pow/logarithm APIs, generic math, overloads, traits, mixed numeric arithmetic, optimizer guarantees, benchmark thresholds, cross-machine performance claims, runtime ABI changes, stable ABI/layout/ownership, or beta maturity are included. ## exp-38 Release label: `exp-38` Release date: 2026-05-19 Release state: released experimental source-facade gates ### Summary Glagol exp-38 implements Standard Host Source Facades Alpha on the Glagol side as fixture, documentation, and promotion-gate coverage. It adds `examples/projects/std-layout-local-random/`, `examples/projects/std-layout-local-env/`, and `examples/projects/std-layout-local-fs/` so ordinary projects explicitly import local facades backed by already promoted `std.random.i32`, `std.env.get`, `std.env.get_result`, `std.fs.read_text`, `std.fs.read_text_result`, `std.fs.write_text`, and `std.fs.write_text_result` calls. The gated facade set is `random_i32`, `random_i32_non_negative`, `get`, `get_result`, `read_text`, `read_text_result`, `write_text_status`, and `write_text_result`. The default promotion gate checks the local fixtures remain explicit. The ignored monorepo Slovo std-source gate now also checks sibling `std/random.slo`, `std/env.slo`, and `std/fs.slo` as part of the exact std source inventory and facade-name alignment. ### Explicit Deferrals No new compiler-known `std.*` names, automatic std import/search path, compiler-loaded std source, seed/range/bytes/float/UUID/crypto random APIs, environment mutation/enumeration, binary/directory/streaming/async filesystem APIs, rich host error ADTs, runtime ABI changes, stable ABI/layout/ownership, or beta maturity are included. ## exp-37 Release label: `exp-37` Release date: 2026-05-19 Release state: released experimental source-facade gates ### Summary Glagol exp-37 implements Standard Time Source Facade Alpha on the Glagol side as fixture, documentation, and promotion-gate coverage. It adds `examples/projects/std-layout-local-time/` so an ordinary project explicitly imports local `time.slo` facades backed by the existing promoted `std.time.monotonic_ms` and `std.time.sleep_ms` calls. The gated facade set is `monotonic_ms` and `sleep_ms_zero`. `sleep_ms_zero` calls `std.time.sleep_ms 0` and returns `0`, because source unit-return facade functions are not promoted. The default promotion gate checks the local fixture remains explicit. The ignored monorepo Slovo std-source gate now also checks repo `lib/std/time.slo` as part of the exact std source inventory and facade-name alignment. ### Explicit Deferrals No new compiler-known `std.*` names, automatic std import/search path, compiler-loaded std source, wall-clock/calendar/timezone APIs, high-resolution timers, async timers, cancellation, scheduling guarantees, runtime ABI changes, stable ABI/layout/ownership, or beta maturity are included. ## exp-36 Release label: `exp-36` Release date: 2026-05-19 Release state: released experimental source-helper gates ### Summary Glagol exp-36 implements Standard Option Source Helpers Alpha on the Glagol side as fixture, documentation, and promotion-gate coverage. It adds `examples/projects/std-layout-local-option/` so an ordinary project explicitly imports local `option.slo` helpers for source-authored `(option i32)` values created with `some` and `none`. The gated helper set is `is_some_i32`, `is_none_i32`, `unwrap_some_i32`, and `unwrap_or_i32`. The default promotion gate checks the local fixture remains explicit and source-authored, with no automatic std imports and no compiler-known `std.option.*` names. The ignored monorepo Slovo std-source gate now also checks repo `lib/std/option.slo` inventory and helper-name alignment. ### Explicit Deferrals No new compiler-known `std.*` names, generic option helpers, option payload families beyond `i32`, source-loaded std modules, automatic std import/search path, runtime ABI changes, manifest schema changes, stable ABI/layout/ownership, or beta maturity are included. exp-95 later broadens the same staged facade and compiler slice to concrete `(option i64)`. ## exp-35 Release label: `exp-35` Release date: 2026-05-19 Release state: released experimental source-helper gates ### Summary Glagol exp-35 implements Standard Result Bool Source Helpers Alpha on the Glagol side as fixture, documentation, and promotion-gate coverage. It extends `examples/projects/std-layout-local-result/` so an ordinary project explicitly imports local `result.slo` helpers for `(result bool i32)` values produced by `std.string.parse_bool_result`. The gated helper set is `is_ok_bool`, `is_err_bool`, `unwrap_ok_bool`, `unwrap_err_bool`, and `unwrap_or_bool`. The default promotion gate checks the local fixture remains explicit and source-authored, with no automatic std imports and no compiler-known `std.result.unwrap_or`. The ignored monorepo Slovo std-source gate now also checks repo `lib/std/result.slo` bool helper-name alignment. ### Explicit Deferrals No source-authored `(result bool i32)` constructors, generic bool result matching, generic result helpers, compiler-known `std.result.unwrap_or`, `std.result.map`, `std.result.and_then`, option helpers, new compiler-known `std.*` runtime calls, runtime ABI changes, automatic std import/search path, compiler-loaded std source, manifest schema changes, stable ABI/layout/ownership, or beta maturity are included. ## exp-34 Release label: `exp-34` Release date: 2026-05-19 Release state: released experimental compiler support ### Summary Glagol exp-34 implements String Parse Bool Result Alpha. The compiler now promotes exactly `std.string.parse_bool_result : (string) -> (result bool i32)`. The release accepts only complete lowercase ASCII `true` and `false`, returns `ok true` or `ok false`, and returns `err 1` for empty strings, uppercase/mixed-case text, leading or trailing whitespace, numeric text, or any other text. Ordinary parse failure does not trap. The compiler lowers the call through the private runtime helper `__glagol_string_parse_bool_result`, and the test runner mirrors the same exact lowercase semantics. The fixture is `examples/string-parse-bool-result.slo`. ### Explicit Deferrals No generic parse APIs, trap-based `std.string.parse_bool`, case-insensitive parsing, whitespace trimming, locale/Unicode parsing, numeric bool parsing, string/bytes parse APIs, rich parse errors, generic result support, source-authored `(result bool i32)` constructors or matches, stable helper ABI/layout/ownership, runtime headers/libraries, manifest schema changes, or beta maturity are included. ## exp-33 Release label: `exp-33` Release date: 2026-05-19 Release state: released experimental source-helper gates ### Summary Glagol exp-33 implements Standard Result Source Helpers Alpha on the Glagol side as fixture, documentation, and promotion-gate coverage. It adds `examples/projects/std-layout-local-result/` so an ordinary project explicitly imports a local `result.slo` module with source-authored helpers over the current concrete result families. The gated helper set is `is_err_i64`, `unwrap_err_i64`, `is_err_string`, `unwrap_err_string`, `is_err_f64`, `unwrap_err_f64`, `unwrap_or_i32`, `unwrap_or_i64`, `unwrap_or_string`, and `unwrap_or_f64`. The default promotion gate checks the local fixture remains explicit and source-authored, with no automatic std imports and no compiler-known `std.result.unwrap_or`. The ignored monorepo Slovo std-source gate now also checks repo `lib/std/result.slo` helper-name alignment. ### Explicit Deferrals No generic result helpers, compiler-known `std.result.unwrap_or`, `std.result.map`, `std.result.and_then`, option helpers, new result payload families, new compiler-known `std.*` runtime calls, runtime ABI changes, automatic std import/search path, compiler-loaded std source, manifest schema changes, stable ABI/layout/ownership, or beta maturity are included. ## exp-32 Release label: `exp-32` Release date: 2026-05-19 Release state: released experimental source-helper gates ### Summary Glagol exp-32 implements Standard Math Source Helpers Alpha on the Glagol side as fixture, documentation, and promotion-gate coverage. It extends `examples/projects/std-layout-local-math/` so an ordinary project explicitly imports a local `math.slo` module with source-authored helpers for the current `i32`, `i64`, and `f64` numeric families. The gated helper set is `abs_i32`, `min_i32`, `max_i32`, `clamp_i32`, `square_i32`, `abs_i64`, `min_i64`, `max_i64`, `clamp_i64`, `square_i64`, `abs_f64`, `min_f64`, `max_f64`, `clamp_f64`, and `square_f64`. The default promotion gate checks the local fixture remains explicit and source-authored, with no `std.*` runtime calls. The ignored monorepo Slovo std-source gate now also checks repo `lib/std/math.slo` helper-name alignment. ### Explicit Deferrals No new compiler-known `std.*` runtime calls, runtime ABI changes, automatic std import/search path, compiler-loaded std source, broad math library, trigonometry/sqrt/pow, `f32`, unsigned or narrower integer families, generic math, overloads, traits, mixed numeric arithmetic, manifest schema changes, stable ABI/layout/ownership, or beta maturity are included. ## exp-31 Release label: `exp-31` Release date: 2026-05-19 Release state: released experimental compiler support ### Summary Glagol exp-31 implements Checked F64 To I64 Result Alpha. The compiler now promotes exactly `std.num.f64_to_i64_result : (f64) -> (result i64 i32)`. The call returns `ok value` only when the input is finite, exactly integral, and inside the signed `i64` range. It returns `err 1` for non-finite, fractional, or out-of-range input without trapping for ordinary conversion failure. The implementation executes in the deterministic test runner, formats through the existing formatter, preserves surface/checked lowering snapshots, and lowers directly to LLVM with ordered range checks before `fptosi`. The promoted fixture is `f64-to-i64-result.slo`. ### Explicit Deferrals No unchecked `f64` to `i64`, casts or cast syntax, generic `cast_checked`, `f32`, unsigned or narrower integer families, additional numeric conversion families, mixed numeric arithmetic, numeric containers, stable ABI/layout, manifest schema changes, or beta maturity are claimed by this slice. ## exp-30 Release label: `exp-30` Release date: 2026-05-19 Release state: released experimental contract-gate support ### Summary Glagol exp-30 implements Standard Library Source Layout Alpha on the compiler side as documentation and gates for the Slovo `lib/std/` source layout contract. The expected Slovo contract files are `std/README.md`, `std/io.slo`, `std/string.slo`, `std/num.slo`, `std/result.slo`, and `std/math.slo`. Glagol adds `examples/projects/std-layout-local-math/`, a normal project-mode fixture that explicitly imports a local `math.slo` module. This demonstrates that the source pattern remains valid for ordinary explicit imports without claiming automatic standard-library loading. The ignored promotion gate `hermeticum_slovo_std_source_layout_alpha_is_preserved` checks the sibling Slovo `lib/std/` layout plus source-shape and formatter stability. ### Explicit Deferrals No new source syntax, new compiler-known standard-runtime functions, automatic `std/` import/search path, package registry behavior, manifest schema changes, self-hosted replacement for compiler-known `std.*` calls, runtime ABI/layout claim, or beta maturity is included. Promoted `std.*` calls continue to execute through `compiler/src/std_runtime.rs`. ## exp-29 Release label: `exp-29` Release date: 2026-05-19 Release state: released experimental compiler support ### Summary Glagol exp-29 implements Numeric Struct Fields Alpha. Top-level structs may use direct immutable `i64` and finite `f64` fields alongside existing direct `i32`, `bool`, immutable `string`, and current enum fields. The release covers struct constructors, immutable local/parameter/return/call flow, field access returning `i64` or `f64`, and use of accessed fields with existing same-type arithmetic/comparison plus existing print and format helpers where those helpers are already supported. The promoted fixture is `numeric-struct-fields.slo`. ### Explicit Deferrals Struct field mutation, nested structs, arrays/vectors/options/results as fields, enum payload widening, numeric containers, `f32`, unsigned or narrower integer families, mixed numeric arithmetic, implicit conversions, new parse/format APIs, generic structs, methods/traits, stable ABI/layout/ ownership, manifest schema changes, FFI layout claims, and beta maturity remain outside this slice. ## exp-28 Release label: `exp-28` Release date: 2026-05-19 Release state: released experimental compiler support ### Summary Glagol exp-28 implements String Parse F64 Result Alpha. The compiler now promotes exactly `std.string.parse_f64_result : (string) -> (result f64 i32)`. The call accepts complete finite ASCII decimal text in the narrow `-?digits.digits` shape, returns `ok value` for finite parsed `f64` values, and returns `err 1` for ordinary parse failure, non-finite text, unsupported leading/trailing characters, or out-of-domain input. The concrete `(result f64 i32)` family is supported for direct fixture flow and existing result helpers without making result handling generic. Source-authored `(ok f64 i32 ...)`, `(err f64 i32 ...)`, and `match` over `(result f64 i32)` remain deferred. The implementation executes in the deterministic test runner, formats through the existing formatter, preserves surface/checked lowering snapshots, and lowers hosted builds through private runtime helper `__glagol_string_parse_f64_result`. The promoted fixture is `string-parse-f64-result.slo`. ### Explicit Deferrals No generic parse, trap-based `std.string.parse_f64`, leading `+`, exponent notation, missing digits around `.`, locale parsing, Unicode digits, underscores, rich parse errors, stable helper ABI/layout, runtime headers/libraries, generic result support, f64 containers, mixed numeric arithmetic, manifest schema changes, or beta maturity are claimed by this slice. ## exp-27 Release label: `exp-27` Release date: 2026-05-19 Release state: released experimental compiler support ### Summary Glagol exp-27 implements Checked F64 To I32 Result Alpha. The compiler now promotes exactly `std.num.f64_to_i32_result : (f64) -> (result i32 i32)`. The call returns `ok value` only when the input is finite, exactly integral, and inside the signed `i32` range. It returns `err 1` for non-finite, fractional, or out-of-range input without trapping for ordinary conversion failure. The implementation executes in the deterministic test runner, formats through the existing formatter, preserves surface/checked lowering snapshots, and lowers directly to LLVM with ordered range checks before `fptosi`. The promoted fixture is `f64-to-i32-result.slo`. ### Explicit Deferrals No unchecked `f64` to `i32`, casts or cast syntax, generic `cast_checked`, `f32`, unsigned or narrower integer families, additional numeric conversion families, f64 parse, mixed numeric arithmetic, numeric containers, stable ABI/layout, runtime headers/libraries, manifest schema changes, or beta maturity are claimed by this slice. ## exp-26 Release label: `exp-26` Release date: 2026-05-18 Release state: released experimental compiler support ### Summary Glagol exp-26 implements F64 To String Alpha. The compiler now promotes exactly `std.num.f64_to_string : (f64) -> string`. The call returns finite decimal ASCII text for promoted finite `f64` inputs. It type checks like other promoted standard-runtime names, executes in the deterministic test runner, formats through the existing formatter, preserves surface/checked lowering snapshots, lowers hosted builds through a private runtime helper, and adds machine diagnostic snapshots for arity, type, context, bool context, standard-name shadowing, and helper-name shadowing. The promoted fixture is `f64-to-string.slo`. ### Explicit Deferrals No `f32`, f64 parse, generic format/display/interpolation, locale/base/radix/ grouping/padding/precision controls, stable NaN/infinity text, implicit conversion, stable helper ABI/layout, runtime headers/libraries, manifest schema changes, or beta maturity are claimed by this slice. ## exp-25 Release label: `exp-25` Release date: 2026-05-18 Release state: released experimental compiler support ### Summary Glagol exp-25 implements String Parse I64 Result Alpha. The compiler now promotes exactly `std.string.parse_i64_result : (string) -> (result i64 i32)`. The call accepts an entire non-empty signed decimal ASCII string, permits only an optional leading `-`, rejects leading `+`, whitespace, underscores, base/radix prefixes, locale forms, Unicode digits, suffixes, and trailing bytes, and returns `ok value` only inside the signed `i64` range. Malformed or out-of-range inputs return `err 1` without ordinary traps. The promoted fixture is `string-parse-i64-result.slo`. The implementation type checks the call, executes it in the deterministic test runner, formats it through the existing formatter, preserves surface/checked lowering snapshots, lowers hosted builds through a private runtime helper, and adds machine diagnostic snapshots for arity, type, context, bool context, standard-name shadowing, and helper-name shadowing. ### Explicit Deferrals No leading `+`, whitespace trimming, locale/base/radix/underscore handling, Unicode digit parsing, f64 parse, bool/string/bytes parse, generic parse, rich parse errors, stable helper ABI/layout, runtime headers/libraries, manifest schema changes, or beta maturity are claimed by this slice. ## exp-24 Release label: `exp-24` Release date: 2026-05-18 Release state: released experimental compiler support ### Summary Glagol exp-24 implements Integer To String Alpha. The compiler now promotes exactly `std.num.i32_to_string : (i32) -> string` and `std.num.i64_to_string : (i64) -> string`. The calls return signed decimal ASCII strings with a leading `-` for negative values and no leading `+`. They type check like other promoted standard-runtime names, execute in the deterministic test runner, format through the existing formatter, and lower to private runtime helpers that allocate strings consistently with current string runtime behavior. The promoted fixture is `integer-to-string.slo`. ### Explicit Deferrals No f64 formatting, parse APIs, locale/base/radix/grouping/padding controls, generic display/format traits, implicit conversions, stable helper ABI/layout, manifest schema changes, or beta maturity are claimed by this slice. ## exp-23 Release label: `exp-23` Release date: 2026-05-18 Release state: released experimental compiler support ### Summary Glagol exp-23 implements Checked I64-To-I32 Conversion Alpha. The compiler now promotes exactly `std.num.i64_to_i32_result : (i64) -> (result i32 i32)`. The call returns `ok value` for signed `i64` inputs in the signed `i32` range `[-2147483648, 2147483647]` and `err 1` for out-of-range inputs. It type checks like other promoted standard-runtime names, executes in the deterministic test runner, formats through the existing formatter, and lowers directly to LLVM range checks plus truncation into the existing `(result i32 i32)` representation. The promoted fixture is `checked-i64-to-i32-conversion.slo`. ### Explicit Deferrals No traps, implicit promotion, unchecked narrowing, cast syntax, additional narrowing conversions, f64 conversions, stable helper ABI/layout, manifest schema changes, or beta maturity are claimed by this slice. ## exp-22 Release label: `exp-22` Release date: 2026-05-18 Release state: released experimental compiler support ### Summary Glagol exp-22 implements Numeric Widening Conversions Alpha. The compiler now promotes exactly `std.num.i32_to_i64 : (i32) -> i64`, `std.num.i32_to_f64 : (i32) -> f64`, and `std.num.i64_to_f64 : (i64) -> f64`. The calls type check like other promoted standard-runtime names, execute in the test runner, format through the existing formatter, and lower directly to LLVM `sext` or `sitofp` conversion instructions. The promoted fixture is `numeric-widening-conversions.slo`. ### Explicit Deferrals Implicit promotion, mixed numeric operators, narrowing or checked conversions, cast syntax, f32, unsigned and narrower integer families, char/bytes/decimal, numeric parse/format APIs, stable ABI/layout, manifest schema changes, and beta maturity remain outside this slice. ## exp-21 Release label: `exp-21` Release date: 2026-05-18 Release state: released experimental compiler support ### Summary Glagol exp-21 implements I64 Numeric Primitive Alpha. The compiler accepts direct `i64` type names, explicit signed decimal `i64` suffix atoms, immutable `i64` locals, parameters, returns, calls, tests, same-type arithmetic and comparison, LLVM `i64` lowering, and `std.io.print_i64 : (i64) -> unit`. The promoted fixture is `i64-numeric-primitive.slo`. ### Explicit Deferrals f32, unsigned integers, narrower signed integer widths, char/bytes/decimal, casts, implicit promotion, mixed numeric operators, i64 containers, i64 enum payloads or struct fields, parse_i64, random i64, stable ABI/layout, manifest schema changes, and beta maturity remain outside this slice. ## exp-20 Release label: `exp-20` Release date: 2026-05-18 Release state: released experimental compiler support ### Summary Glagol exp-20 implements F64 Numeric Primitive Alpha. The language now accepts direct `f64` type names and float atoms, checks f64 locals, parameters, returns, calls, top-level tests, arithmetic `+ - * /`, equality, and ordered comparisons when both operands are `f64`, and emits LLVM `double` value flow. The standard runtime promotes exactly `std.io.print_f64 : (f64) -> unit`, lowering to `print_f64(double)` in `runtime/runtime.c` with `%.17g\n` formatting. The promoted fixture is `f64-numeric-primitive.slo`. ### Explicit Deferrals f32, i64/u64/u32/u16/u8/i16/i8, char, bytes, decimal, casts, mixed i32/f64 arithmetic or comparison, f64 arrays/vectors/options/results/enum payloads/ struct fields, parse_f64, random floats, stable ABI/layout, manifest schema changes, and beta maturity remain outside this slice. ## exp-19 Release label: `exp-19` Release date: 2026-05-18 Release state: released experimental compiler support ### Summary Glagol exp-19 implements Primitive Struct Fields Alpha. Top-level structs may use direct `bool` and immutable `string` fields alongside existing direct `i32` fields and exp-18 direct enum fields. The slice covers struct construction, field access, immutable struct locals, parameters, returns, calls, top-level tests, lowering inspection, formatter stability, and LLVM aggregate emission for direct primitive fields. The promoted fixture is `primitive-struct-fields.slo`. ### Explicit Deferrals Arrays, vectors, options, and results containing primitive fields remain unsupported as struct fields. Nested structs, struct field/value mutation, broader string ownership and cleanup promises, generics, methods/traits, stable ABI/layout, manifest schema changes, import/package widening, and beta maturity remain outside this slice. ## exp-18 Release label: `exp-18` Release date: 2026-05-18 Release state: released experimental compiler support ### Summary Glagol exp-18 implements Enum Struct Fields Alpha. Top-level structs may use current user-defined enum types directly as fields, alongside existing `i32` fields. This covers payloadless enums and unary `i32` payload enum values in struct construction, field access, immutable locals, parameters, returns, calls, same-enum equality, exhaustive enum matches, top-level tests, and `main`. The promoted fixture is `enum-struct-fields.slo`, with formatter and lowering snapshots plus focused diagnostics for enum containers inside struct fields. ### Explicit Deferrals Arrays, vectors, options, and results containing enums remain unsupported as struct fields and continue to report `UnsupportedEnumContainer`. Nested struct fields, struct/enum mutation, printing enum values, enum ordering/hash/ reflection/discriminants, broader enum payloads, generics, stable ABI/layout, manifest schema changes, package registry behavior, import aliases/globs/ re-exports, and beta maturity remain outside this slice. ## exp-17 Release label: `exp-17` Release date: 2026-05-18 Release state: released experimental compiler support ### Summary Glagol exp-17 implements Project/Workspace Enum Imports Alpha. Top-level enum declarations now participate in flat project and local workspace visibility: modules can export enum names and consumers can import those enum types alongside functions and structs. Imported enums preserve exp-4 payloadless and exp-16 unary `i32` payload metadata across module and package boundaries. Imported enum values work in function signatures, immutable locals, calls/returns, qualified constructors, same-enum equality, exhaustive enum matches, `main`, and tests. The promoted project fixture is `examples/projects/enum-imports/`. ### Explicit Deferrals Non-`i32` payload types, multiple payloads, record variants, enum containers, enum mutation, enum printing, enum ordering/hash/reflection/discriminants, generics, stable ABI/layout, manifest schema changes, registry/package-manager behavior, and beta maturity remain outside this slice. ## exp-16 Release label: `exp-16` Release date: 2026-05-18 Release state: released experimental compiler support ### Summary Glagol exp-16 implements Unary I32 Enum Payloads Alpha. User enum declarations may mix payloadless variants with unary `i32` payload variants, for example `(Value i32)`. Qualified constructors support `(Reading.Missing)` and `(Reading.Value value)`, and exhaustive enum matches require no binding for payloadless variants and exactly one immutable arm-local `i32` binding for payload variants. Enum values flow through immutable locals, parameters, returns, calls, tests, `main`, and same-enum equality. Equality compares tag plus payload for payload enums and tag only for payloadless enums. LLVM and the test runner use a compiler-owned `{ i32, i32 }` tag/payload representation for payload enums; this is not a stable ABI or layout claim. The promoted fixture is `enum-payload-i32.slo`, with formatter and lowering snapshots plus focused diagnostics for unsupported payload types, constructor arity/type failures, and match binding requirements. ### Explicit Deferrals Non-`i32` payload types, multiple payloads, record variants, generic enums/functions, wildcard/rest/nested enum patterns, pattern guards, enum values in containers, enum mutation, enum printing, enum ordering/hash/ reflection/discriminants, runtime/runtime.c changes, stable ABI/layout, manifest schema changes, and beta maturity remain outside this slice. ## exp-15 Release label: `exp-15` Release date: 2026-05-18 Release state: released experimental compiler support ### Summary Glagol exp-15 implements Result Helper Standard Names Alpha. It accepts `std.result.is_ok`, `std.result.is_err`, `std.result.unwrap_ok`, and `std.result.unwrap_err` for exactly `(result i32 i32)` and `(result string i32)`, mapping them to the existing result observer and unwrap behavior. Legacy `is_ok`, `is_err`, `unwrap_ok`, and `unwrap_err` remain supported. No `std.result.map`, `std.result.unwrap_or`, `std.result.and_then`, option standard names, generic results, new result payload families, runtime API, manifest schema change, or beta maturity is claimed. ## exp-14 Release label: `exp-14` Release date: 2026-05-18 Release state: released experimental conformance alignment ### Summary Glagol exp-14 is the Standard Runtime Conformance Alignment release. It aligns docs, fixtures, formatter/lowering snapshots, promotion inventories, and a focused conformance gate over the already released exp-13 surface plus released exp-8 time/sleep support. It is not beta. This release adds no source syntax, type forms, standard-library operations, runtime APIs, ABI/layout promises, or manifest schema changes. ### Gate The focused conformance gate, full release gate, and Slovo/Glagol review pass together. The new time/sleep fixture uses only `std.time.monotonic_ms` and `std.time.sleep_ms 0`; it does not assert positive-duration timing behavior. ## exp-13 Release label: `exp-13` Release date: 2026-05-18 Release state: released experimental compiler support ### Summary Glagol exp-13 implements Slovo exp-13 String Parse I32 Result Alpha as released experimental compiler support. It is not beta. The release promotes exactly one standard-runtime call: - `std.string.parse_i32_result : (string) -> (result i32 i32)` The operation parses an entire ASCII decimal signed `i32` string and returns `ok value` on success or ordinary parse failure as `err 1`. ### Release State The fixture, diagnostics, lowering snapshots, and promotion inventories are released experimental compiler-support state after the implementation, diagnostics, lowering-inspector snapshots, runtime/test-runner behavior, promotion gates, release review, and full release gate passed. No trap-based `std.string.parse_i32`, float/bool/string/bytes parsing, whitespace/locale/base-prefix/underscore/plus-sign parsing, generic parse API, rich parse errors, Unicode digit parsing, string indexing/slicing, tokenizer/scanner API, stdin line API, manifest schema changes, stable helper ABI/layout, runtime headers/libraries, or beta maturity is claimed. ## exp-12 Release label: `exp-12` Release date: 2026-05-18 ### Summary Glagol exp-12 implements Slovo exp-12 Standard Input Result Alpha as released experimental compiler support. It is not beta. The release promotes exactly one standard-runtime call: - `std.io.read_stdin_result : () -> (result string i32)` The release returns `ok` with remaining stdin text, including ordinary EOF as `ok ""`; ordinary host/input failure returns `err 1`. ### Release State exp-12 is released experimental compiler support after the implementation, Slovo fixture alignment, formatter, diagnostics, lowering-inspector snapshots, test-runner, LLVM/runtime, promotion gates, release review, and full release gate passed. No trap-based `std.io.read_stdin`, line iteration, prompt APIs, terminal mode, binary stdin, streaming, async stdin, encoding/Unicode promise, stable helper ABI/layout, runtime headers/libraries, manifest schema change, or beta maturity is claimed. ## exp-11 Release label: `exp-11` Release date: 2026-05-18 ### Summary Glagol exp-11 implements Slovo exp-11 Basic Randomness Alpha. It is released experimental compiler support, not beta. The release promotes exactly one standard-runtime call: - `std.random.i32 : () -> i32` The call returns a non-negative implementation-owned `i32` suitable only for basic command-line programs. If native runtime randomness is unavailable, the runtime trap text must be exactly `slovo runtime error: random i32 unavailable`. ### Release State exp-11 is released experimental compiler support after Slovo and Glagol fixtures, formatter, diagnostics, lowering-inspector snapshots, test-runner, LLVM/runtime, promotion gates, release review, and release gates passed. No seed APIs, deterministic public sequences, cryptographic suitability, range/bounds APIs, bytes, strings, UUIDs, artifact-manifest schema changes, stable helper ABI, runtime headers/libraries, or beta maturity are claimed. ## exp-10 Release label: `exp-10` Release date: 2026-05-18 ### Summary Glagol exp-10 implements Slovo exp-10 Result-Based Host Errors Alpha. It is released experimental compiler support, not beta. The release promotes exactly one new concrete result family, `(result string i32)`, and four additive host calls: - `std.process.arg_result : (i32) -> (result string i32)` - `std.env.get_result : (string) -> (result string i32)` - `std.fs.read_text_result : (string) -> (result string i32)` - `std.fs.write_text_result : (string string) -> (result i32 i32)` Ordinary host failure returns `err 1`. The exp-3 calls remain unchanged: argument/read failures still trap, missing environment variables still return `""`, and writes still return `0` or `1`. ### Release State exp-10 is released experimental compiler support after formatter, checker, lowering, diagnostics, test-runner, LLVM/runtime, fixture-alignment, release review, and release gates passed. ## exp-9 Release label: `exp-9` Release date: 2026-05-18 ### Summary Glagol exp-9 is the released experimental hardening slice over the released exp-8 surface. The exp-9 work includes compatibility inventory, migration guide, source-reachable panic audit, benchmark smoke notes, release gate evidence, and deterministic hardening tests in `compiler/tests/reliability_hardening.rs`. Controller verification has passed the focused exp-9 hardening test and the full local release gate. Benchmark smoke records structured `ToolchainUnavailable` for hosted native-build checks because `clang` was not on PATH in this environment. exp-9 is hardening-only. It does not add source syntax, type-system behavior, standard-runtime names, runtime capabilities, package features, manifest schema versions, stable ABI/layout promises, public performance thresholds, or beta maturity. ### Release State exp-9 is released experimental compiler support after matching Slovo and Glagol gates. ## exp-8 Release label: `exp-8` Release date: 2026-05-18 ### Summary Glagol exp-8 implements the conservative host time and sleep alpha. It adds exactly two compiler-known standard-runtime calls: - `std.time.monotonic_ms : () -> i32` - `std.time.sleep_ms : (i32) -> unit` `std.time.monotonic_ms` returns non-negative process-relative host monotonic elapsed milliseconds, saturating to `i32::MAX`. `std.time.sleep_ms` accepts non-negative millisecond durations; `0` is valid and deterministic in the test runner. ### Diagnostics And Limits Negative sleeps trap as `slovo runtime error: sleep_ms negative duration`. Hosted runtime failure to read monotonic time traps as `slovo runtime error: monotonic time unavailable`; non-negative sleep failure may trap as `slovo runtime error: sleep failed`. exp-8 adds no source syntax, wall-clock/calendar API, time zones, high-resolution clock contract, timers, threads, channels, async behavior, scheduling guarantees, cancellation, or stable helper ABI. The current artifact manifest has no general standard-runtime usage structure, so exp-8 does not add one-off time metadata. ## exp-7 Release label: `exp-7` Release date: 2026-05-18 ### Summary Glagol exp-7 implements the experimental test selection and test-run metadata alpha. `glagol test --filter ` and the legacy single-file `glagol --run-tests --filter ` route select tests by deterministic, case-sensitive display-name substring matching. Selected tests execute in existing order. Non-selected discovered tests are skipped before evaluation and counted as skipped. Zero matches is a successful run. Text output and artifact manifests expose `total_discovered`, `selected`, `passed`, `failed`, `skipped`, and optional `filter` metadata. ### Diagnostics And Limits Missing filter values, repeated `--filter`, and use of `--filter` outside test mode are command-line diagnostics. The exp-6 C-import test-runner boundary is unchanged: selected tests that reach imported C calls report `UnsupportedTestExpression`, while non-selected C-import tests are skipped before evaluation. LSP/editor protocols, debug metadata, source maps, SARIF, watch/daemon behavior, documentation comments, lint categories, benchmark behavior, test tags/groups/retries/parallelism, and new Slovo source syntax are deferred. exp-7 is experimental, not beta. ## exp-6 Release label: `exp-6` Release date: 2026-05-18 ### Summary Glagol exp-6 implements the experimental C FFI scalar imports alpha. It accepts top-level imports such as: ```slo (import_c c_add ((lhs i32) (rhs i32)) -> i32) ``` Imported C functions use conservative C symbol names, accept only `i32` parameters, and return only `i32` or builtin `unit`. Calls to imported C functions are allowed only inside lexical `(unsafe ...)`; calls outside unsafe report `UnsafeRequired`. Native builds lower imports to LLVM external declarations and direct calls. `glagol build --link-c ` links explicit local C source inputs, and artifact manifests record `foreign_imports` plus `c_link_inputs`. ### Diagnostics And Limits The interpreter-style test runner does not execute imported C calls in exp-6; tests that reach a C import report `UnsupportedTestExpression`. Raw unsafe heads, including `ffi_call`, remain unsupported operations. Pointers, raw allocation/deallocation, raw unsafe head execution, ownership/lifetime rules, C exports, callbacks, headers/libraries, broad linker configuration, and stable ABI/layout are deferred. exp-6 is experimental, not beta. ## exp-5 Release label: `exp-5` Release date: 2026-05-18 ### Summary Glagol exp-5 implements the experimental local packages/workspaces alpha. A workspace `slovo.toml` can declare `[workspace] members`, and each member can declare `[package] name`, `version`, `source_root`, `entry`, plus local `[dependencies]` entries such as `mathlib = { path = "../mathlib" }`. The implemented slice builds a deterministic closed local package graph, accepts package-qualified imports such as `(import mathlib.math (add_one))`, checks cross-package visibility through existing module export lists, and records the workspace/package graph in artifact manifests. ### Diagnostics The exp-5 diagnostic gate covers missing package manifests or packages, duplicate package names, dependency cycles, workspace/dependency/source-root path escapes, invalid package names, invalid package versions, private cross-package visibility, and dependency key/name mismatches. ### Explicit Deferrals Registries, lockfiles, semver solving, aliases, globs, re-exports, generated code, build scripts, publishing, optional/dev/target dependencies, stable package ABI, and remote dependencies remain outside this experimental slice. exp-5 is not beta and is not package-manager support. ## exp-4 Release label: `exp-4` Release date: 2026-05-18 ### Summary Glagol exp-4 implements experimental payloadless user-defined enum support. Enums can be declared with one or more unique variants, constructed through qualified constructors such as `(Signal.Red)`, compared for equality when both operands have the same enum type, passed through immutable locals, parameters, returns, calls, and top-level tests, and matched exhaustively by variant. The promoted release fixture is `enum-basic.slo`, byte-aligned with Slovo's supported fixture. Lowering inspector snapshots cover both surface and checked enum forms, and diagnostics snapshots cover the exp-4 boundary cases. ### Explicit Deferrals Payload variants, generic ADTs, type aliases, traits, methods, unqualified variant constructors, enum mutation, enum printing, enum ordering, enum values inside containers, stable layout, and stable ABI claims remain outside this slice. Unqualified variant constructor calls currently report the generic `UnknownFunction` diagnostic. ### Gates The exp-4 gate covers Slovo/Glagol fixture equality for `enum-basic.slo`, formatter and lowering-inspector fixtures, enum LLVM discriminant shape, top-level enum tests, and golden machine diagnostics for supported boundary failures. ## exp-3 Release label: `exp-3` Release date: 2026-05-17 ### Summary Glagol exp-3 implements the conservative standard IO and host-environment slice. It adds compiler-known standard-runtime functions: - `std.io.eprint : (string) -> unit` - `std.process.argc : () -> i32` - `std.process.arg : (i32) -> string` - `std.env.get : (string) -> string` - `std.fs.read_text : (string) -> string` - `std.fs.write_text : (string string) -> i32` Missing environment variables return an empty string. `write_text` returns `0` on success and `1` on host failure. `eprint` writes to stderr without adding a newline. Native programs initialize a private runtime process view from host `argc`/`argv`. Runtime traps are: - `slovo runtime error: process argument index out of bounds` - `slovo runtime error: file read failed` The runtime helper symbols are private implementation details and are reserved from source/project names. exp-3 does not stabilize host error payloads, file ownership/lifetime behavior, process layout, runtime ABI, or C helper symbols. ### Explicit Deferrals Networking, async IO, binary IO, directory traversal, terminal control, stdin full-read/iteration, time, randomness, result-string host errors, and stable ABI/layout claims remain outside this slice. ### Gates The exp-3 gate covers checker diagnostics, lowering-inspector fixtures, LLVM runtime-call shape, interpreted host behavior where practical, hosted runtime smoke tests, and trap behavior for process arguments and file reads. ## exp-2 Release label: `exp-2` Release date: 2026-05-17 ### Summary Glagol exp-2 implements the first collections alpha slice from the Slovo contract. It adds one concrete growable vector type, `(vec i32)`, plus compiler-known standard-runtime functions: - `std.vec.i32.empty : () -> (vec i32)` - `std.vec.i32.append : ((vec i32), i32) -> (vec i32)` - `std.vec.i32.len : ((vec i32)) -> i32` - `std.vec.i32.index : ((vec i32), i32) -> i32` `append` returns a new immutable runtime-owned vector. `(vec i32)` values can flow through immutable locals, parameters, returns, calls, top-level tests, formatter output, lowering inspection, LLVM, runtime C, and the test runner. Vector equality with `=` compares `(vec i32)` values by length and element contents. Runtime traps are: - `slovo runtime error: vector allocation failed` - `slovo runtime error: vector index out of bounds` The runtime helper symbols are private implementation details and are reserved from source/project names. exp-2 does not stabilize vector layout, C ABI, allocator behavior, lifetime, destruction, FFI, or ownership semantics. ### Explicit Deferrals Generic vectors, non-`i32` elements, vector mutation through `var` or `set`, `push` aliases, nested vectors, vectors inside arrays/structs/options/results, slices, maps, sets, user-visible allocation/deallocation, and stable layout or ABI promises remain outside this slice. ### Gates The exp-2 release gate covers checker diagnostics, formatter stability, lowering-inspector fixtures, LLVM runtime-call shape, top-level test-runner evaluation, hosted runtime smoke tests, vector trap behavior, allocation-trap probing, promotion-gate inventory, and Slovo fixture alignment without editing Slovo fixtures. ## exp-1 Release label: `exp-1` Release date: 2026-05-17 ### Summary Glagol exp-1 implements the first owned-runtime-string slice from the Slovo contract. It adds compiler-known `std.string.concat` with signature `(string, string) -> string`, returning an immutable runtime-owned `string`. Existing string equality, `std.string.len`, `std.io.print_string`, string locals, parameters, returns, and calls can use the result. No legacy `string_concat` alias is accepted. The runtime helper is private implementation detail, not a stable ABI, layout, allocator, lifetime, or FFI promise. ### Gates The exp-1 release gate covered checker diagnostics, formatter stability, lowering-inspector fixtures, LLVM runtime-call shape, top-level test-runner evaluation, hosted runtime smoke tests, and Slovo fixture alignment. ## v2.0.0-beta.1 Release tag: `v2.0.0-beta.1` Release date: 2026-05-17 ### Summary Glagol `v2.0.0-beta.1` is an experimental gate/readiness release over the completed v1.7 toolchain. It does not add new Slovo source syntax or semantics. The release documents the current supported surface and proves the integrated experimental workflow through project scaffolding, `fmt --check`, `test`, `doc`, and hosted `build` when the host toolchain is available. ### Experimental-Supported Surface - v1.7 CLI and project tooling, including `new`, `fmt --check`, `fmt --write`, `doc`, `test`, and hosted `build`. - Flat local project mode with explicit imports and exports. - v1.5 standard-runtime alpha as the basic IO/string subset: `std.io.print_i32`, `std.io.print_string`, `std.io.print_bool`, and `std.string.len`. - Fixed-size immutable `i32` arrays as the current collection subset. - Existing v1.7 language behavior for strings, structs, option/result values, exact option/result `match`, and lexical unsafe diagnostics. ### Explicit Deferrals At tag time, the experimental release deferred vectors and growable collections, packages and registries, stable ABI/layout, FFI, executable raw-memory behavior, LSP/watch mode, stable debug metadata, source-map files, direct machine-code output, and self-hosting until future beta work. The later `exp-2` slice now implements only the narrow `(vec i32)` collections alpha. ### Release Gates The experimental gate runs through `scripts/release-gate.sh`: whitespace checks, `cargo fmt --check`, full `cargo test`, and the ignored promotion, binary, and LLVM smoke gates. Full `cargo test` includes the v1.7 DX gate and the experimental workflow proof. ## v1.7 Release tag: `v1.7` Release date: 2026-05-17 ### Summary Glagol v1.7 is a Developer Experience Hardening release. It adds conservative tooling around the existing Slovo v1.6 language surface and does not introduce new Slovo syntax or semantics. ### Tooling Additions - `glagol new [--name ]` scaffolds a minimal project with `slovo.toml` and `src/main.slo`. - `glagol fmt --check ` verifies canonical formatting without writes and reports `FormatCheckFailed` when a file would change. - `glagol fmt --write ` writes canonical formatting in place and emits no stdout on success. - `glagol doc -o ` writes deterministic Markdown documentation to `index.md`. - `scripts/release-gate.sh` runs the local release gate. ### Explicit Deferrals v1.7 does not add package management, workspaces, nested modules, import aliases, semantic reflection, LSP/watch mode, new formatter semantics beyond existing project syntax, or any new Slovo language behavior. ## v1.6 Release tag: `v1.6` Release date: 2026-05-17 ### Summary Glagol v1.6 is the Memory And Unsafe Design Slice release. It mirrors Slovo's conservative v1.6 contract by hardening the reserved unsafe vocabulary and lexical unsafe diagnostics without promoting executable raw-memory behavior. The v1.1 through v1.5 sections below are historical release records. The compiler-known unsafe operation heads are: - `alloc` - `dealloc` - `load` - `store` - `ptr_add` - `unchecked_index` - `reinterpret` - `ffi_call` ### Diagnostics And Reservation Outside lexical `(unsafe ...)`, each unsafe head reports `UnsafeRequired` before user-function lookup. Inside lexical `(unsafe ...)`, each head reports `UnsupportedUnsafeOperation`. These names are reserved from user functions, project imports and exports, parameters, locals, structs, and match payload bindings where the current reservation architecture applies. This keeps the vocabulary available for a future contract without allowing accidental shadowing today. ### Explicit Deferrals v1.6 does not introduce raw pointers, allocation/deallocation semantics, pointer load/store, pointer arithmetic, unchecked indexing execution, reinterpretation, FFI calls, stable ABI/layout promises, runtime C symbols, or raw-memory LLVM lowering. ### Release Gates v1.6 verification covers unsafe-required and unsupported-inside-unsafe diagnostic snapshots for every unsafe head, focused reservation tests for local source and project visibility paths, existing lexical unsafe formatter and lowering fixtures, and regressions proving no raw unsafe operation reaches LLVM lowering. ## v1.5 Release tag: `v1.5` Release date: 2026-05-17 ### Summary Glagol v1.5 is the Standard Library Alpha release. It mirrors Slovo's conservative v1.5 contract by promoting stable source-level standard-runtime names for existing runtime behavior without adding modules, imports, packages, new IO breadth, allocation, Unicode length semantics, or ABI promises. The v1.1 through v1.4 sections below are historical release records. v1.5 promotes: - `std.io.print_i32` - `std.io.print_string` - `std.io.print_bool` - `std.string.len` These are compiler-known source-level standard-runtime names. They do not require imports, do not name user modules, do not create package dependencies, are not foreign functions, and are not stable C ABI symbols. Legacy `print_i32`, `print_string`, `print_bool`, and `string_len` remain compatibility aliases. New examples should prefer the promoted `std.*` names. ### Diagnostics And Deferrals Unknown or unpromoted `std.*` calls must produce structured diagnostics, with `UnsupportedStandardLibraryCall` as the suggested code. Arity and type mismatches use the existing diagnostics where applicable. The exact promoted `std.*` names are reserved from user function/export shadowing. v1.5 does not support `std.io.print_unit`, file IO, environment variables, process arguments, time or clocks, collections, allocation, deallocation, ownership, user-defined standard modules, imports or packages for standard-runtime names, overloading, generic standard-library APIs, Unicode scalar/grapheme/display-width string length, stable C ABI symbols, runtime layout promises, or FFI contracts. ### Release Gates v1.5 verification covers parser/lowerer/checker/formatter support for the promoted `std.*` calls, aligned `examples/standard-runtime.slo` and `tests/standard-runtime.slo` fixtures, lowering-inspector snapshots, runtime smoke tests matching legacy stdout and byte-length behavior, diagnostic snapshots for the v1.5 boundaries, and regressions proving v1.4, v1.3, and v1.2 behavior remains unchanged. ## v1.4 Release tag: `v1.4` Release date: 2026-05-17 ### Summary Glagol v1.4 is the Core Language Expansion release. It mirrors Slovo's conservative source-level `match` contract for existing option/result values without widening into enums, generics, mutation, vectors, or ABI promises. - Promotes `match` for exactly `(option i32)` and `(result i32 i32)` subjects. - Requires exhaustive two-arm forms: `some` and `none` for options, `ok` and `err` for results. - Adds immutable `i32` payload binding for `some`, `ok`, and `err`; payload bindings are visible only inside the selected arm body. - Treats each arm body as an arm-scoped sequential body with one or more expressions; the final expression is the arm value. - Types the `match` expression as the common arm result type. - Keeps existing `is_some`, `is_none`, `is_ok`, `is_err`, `unwrap_some`, `unwrap_ok`, and `unwrap_err` supported, while new examples should prefer `match` for payload-dependent option/result control flow. ### Diagnostics And Formatting The v1.4 diagnostic boundary requires stable codes for match subject type mismatches, unsupported payload types, non-exhaustive matches, duplicate arms, malformed patterns, arm result type mismatches, binding collisions, unsupported mutation, and unsupported option/result container positions. The formatter target is a canonical multiline `match` shape: the head and subject stay on the opening line, each arm starts on its own line, pattern lists stay inline, and body expressions use the normal nested body indentation. The formatter preserves arm order and does not repair malformed arm sets. ### Deferred From v1.4 - User-defined enums or algebraic data types. - Generic, non-`i32`, or nested option/result payload matching beyond the current v1 limits. - Options/results inside arrays, structs, or other containers. - Mutation of option/result values, struct fields, arrays, or vectors. - `i64` or broader numeric expansion. - General `(block ...)` expressions outside match arms. - Pattern guards, wildcard/rest/catch-all patterns, and destructuring. - Result-oriented standard-library error conventions. - User-catchable exceptions, ownership, lifetime, layout, or ABI guarantees. ### Release Gates v1.4 verification covers parser/lowerer/checker/formatter support for the promoted match surface, fixture alignment with Slovo `examples/supported/option-result-match.slo`, formatter idempotence for Slovo `examples/formatter/option-result-match.slo`, lowering-inspector snapshots, LLVM or runtime smoke tests for arm selection and payload binding, diagnostic snapshots for every required match code, and regressions proving v1.3 project mode and v1.2 runtime values remain unchanged. ## v1.3 Release tag: `v1.3` Release date: 2026-05-17 ### Summary Glagol v1.3 implements Slovo's conservative Project Mode And Modules contract. The release target is local, manifest-based, flat multi-file projects while preserving v1.2 single-file `.slo` command behavior. - Project manifests are named `slovo.toml` and contain `[project]` with required `name`, optional `source_root = "src"`, and optional `entry = "main"`. `name` is lowercase package-shaped text, `source_root` must remain under the project root, `entry` is a flat module identifier, and unknown sections or keys are diagnostics. - `glagol check`, `glagol test`, and `glagol build` enter project mode only when given a project root or the `slovo.toml` file itself. - Project source discovery is limited to immediate `.slo` files under the flat source root. - Modules can declare explicit exports, for example `(module math (export add_one Point))`. - Modules can import explicit exported names, for example `(import math (add_one Point))`. - Project diagnostics preserve multi-file source identity and cover manifest failures, missing imports, import cycles, duplicate names, visibility failures, ambiguous imports, and unsupported path/module boundaries. - Project artifact manifests record project roots, manifests, source roots, modules, import edges, diagnostics, tests, and build outputs in deterministic order. ### Deferred From v1.3 - Packages, package namespaces, dependencies, remote registries, lockfiles, and workspaces. - Import aliases, renames, glob imports, qualified imports, conditional imports, and re-exports. - Nested or hierarchical modules. - Project formatting, write-in-place formatting, and directory formatting. - Path escapes from the project root or source root, generated sources, watch mode, LSP/editor protocols, and incremental builds. - Build profiles, target triples, cross-compilation, object/library/header outputs, package artifacts, public ABI promises, and stable debug metadata. ### Release Gates v1.3 verification covers manifest parsing and diagnostics, project `check`/`test`/`build` command behavior, `examples/projects/basic` fixture alignment, diagnostic-family checks for import/export failures, deterministic module-order checks, cross-file related-span checks, project artifact-manifest snapshots for success and failure paths, and single-file regressions proving v1.2 mode is unchanged. ## v1.2 Release tag: `v1.2` Release date: 2026-05-17 ### Summary Glagol v1.2 implements the Slovo v1.2 Practical Runtime Values contract while preserving the v1.1 single-file CLI/toolchain surface. - Immutable string value flow through string `let` locals, parameters, returns, and calls returning strings. - String equality through `=`. - String byte length through temporary compiler/runtime intrinsic `string_len`. - Boolean printing through temporary compiler/runtime intrinsic `print_bool`. - Deterministic runtime trap messages and process exit code `1` for array bounds failures and option/result unwrap failures. ### Deferred From v1.2 - `print_unit`. - Mutable strings, string `var` locals, and `set` of string locals. - String concatenation, indexing, slicing, ownership, allocation/free, and stable ABI/layout/FFI promises. - Strings inside arrays, structs, options, or results. - Project mode, imports, package management, and multi-file modules. - Any change to the v1.1 CLI/toolchain surface. ### Release Gates Final v1.2 verification includes the existing v1.1 gates plus fixture alignment for `string-value-flow.slo` and `print-bool.slo`, formatter idempotence, lowering-inspector snapshots, diagnostic snapshots for deferred forms, runtime smoke tests for strings and traps, and process-exit tests for runtime traps. ## v1.1 Release tag: `v1.1` Release date: 2026-05-17 ## Summary Glagol v1.1 productizes the hosted single-file toolchain without expanding the Slovo v1 language surface. ### Canonical Commands - Added `glagol check ` for parse/lower/check/backend-support validation with no primary output. - Added `glagol fmt ` as the canonical formatter command. - Added `glagol test ` as the canonical top-level test runner. - Added `glagol build -o ` for hosted native builds through emitted LLVM IR, `runtime/runtime.c`, and Clang. - Preserved v1 compatibility aliases: default LLVM emission, `--emit=llvm`, `--format`, `--print-tree`, `--inspect-lowering=surface`, `--inspect-lowering=checked`, `--check-tests`, and `--run-tests`. ### Diagnostics, Manifests, And Exit Codes - Added `--json-diagnostics` newline-delimited JSON diagnostics using `slovo.diagnostic` schema version `1`. - Added `--no-color` across canonical commands and compatibility modes. - Extended artifact manifests with command modes, diagnostics encoding, no-output check manifests, build output artifacts, and failure manifests when `--manifest ` has been parsed. - Implemented the v1.1 exit-code table: `0` success, `1` source/input/test failure, `2` usage error, `3` hosted toolchain failure, `4` internal compiler error, and `5` manifest or output artifact write failure. ### Hosted Build - `glagol build` locates Clang through `GLAGOL_CLANG` or `PATH`. - Missing Clang, missing runtime C, and failed Clang execution are reported as toolchain failures with exit code `3`. - Native output is staged through a temporary file in the destination directory before replacing the requested `-o` path on success. - Project mode, profiles, cross targets, object/library outputs, custom linker flags, and stable ABI promises remain deferred. ## v1 Release tag: `v1` Release date: 2026-05-17 ## Summary Glagol v1 is the compiler release for the Slovo v1 contract. It keeps the tree-first compiler pipeline visible, expands value flow beyond v0, and hardens the CLI/tooling surface without claiming direct native executable output. The default successful primary output remains LLVM IR text. Native execution is the explicit external workflow: emitted LLVM IR plus `runtime/runtime.c` and Clang. ### Promoted v1 Value Flow - Added immutable struct locals, struct parameters, struct returns, calls returning structs, and stored field access for the promoted Slovo v1 struct slice. - Added immutable fixed-size `i32` array locals, parameters, returns, calls returning arrays, and runtime-checked dynamic indexing with a runtime trap. - Added option/result value flow for the `i32` subset, including immutable option/result locals, parameters, calls returning option/result values, tag observation, and explicit payload extraction with trap-based invalid unwraps. - Added a narrow string runtime slice: direct string literals lower to borrowed immutable NUL-terminated static storage as LLVM `ptr`, and the temporary `print_string` intrinsic prints one string plus a newline through the runtime. - Kept full option/result matching, full string value flow, broad runtime printing, raw unsafe memory/FFI operations, stable ABI/layout promises, and stable debug metadata deferred for the v1 scope freeze. ### CLI Polish - Added `--emit=llvm` as the explicit spelling for the default LLVM IR emission mode. - Added `-o ` to route successful primary output to a file instead of stdout. - Added `--version`, reported from Cargo package metadata. - Kept stdin source input deferred until source naming and span behavior are specified. - Kept JSON diagnostics and lowering-inspection output deferred until the text contract needs a versioned machine-readable companion. ### Slovo v1 Tooling Contract - Updated machine diagnostics to the Slovo v1 textual schema with root `(diagnostic ...)`, `(schema slovo.diagnostic)`, and `(version 1)`. - Added `--manifest ` to write `slovo.artifact-manifest` version `1` manifests for successful primary modes and source-diagnostic failures. - Added `UnsupportedUnitSignatureType` diagnostics for user-written `unit` parameter and return signatures while keeping `unit` internal to compiler/runtime unit-producing forms. - Added golden lowering-inspector snapshots for every promoted v1 fixture in both surface and checked modes. - Audited the golden diagnostic matrix and added snapshots for the current unsupported string escape, string literal, and bare string expression boundaries. - Kept primary output on stdout or `-o` and diagnostics on stderr; direct native executable output remains deferred behind the LLVM-plus-Clang workflow. - Clarified that artifact manifests are invocation records for textual artifacts, not native executable output. ### Formatter And Inspection Stability - Added the v1 formatter stability contract for supported comments, nested promoted forms, and long inline forms. - Added full-line comment preservation fixtures and structured `UnsupportedFormatterComment` rejection for unsupported comment positions, including same-line/trailing comments. - Added golden `--inspect-lowering=surface` and `--inspect-lowering=checked` snapshots for every promoted v1 fixture family, including formatter comments/stability fixtures accepted by inspector mode. - Expanded the golden diagnostic matrix for Slovo's required rejected v1 boundaries: struct duplicate/unknown/mutation shapes, non-`i32` option/result signature payloads, and array promoted-flow type mismatches. ### Release Gates Final v1 verification covers: ```text cargo test cargo fmt --check cargo test --test promotion_gate -- --ignored cargo test --test binary_smoke -- --ignored cargo test --test llvm_smoke -- --ignored git diff --check ``` ## v0 Release tag: `v0` Release date: 2026-05-16 Release commit: `4ccd201` ## Summary Glagol v0 is the first released compiler for Slovo. It implements the Slovo v0 language contract as a Rust binary CLI that parses, formats, checks, tests, inspects, lowers, and emits LLVM IR for the supported fixture set. v0 intentionally keeps the compiler surface small and explicit. The default output is LLVM IR text; direct executable output remains deferred. ## CLI Surface Supported v0 commands: ```text glagol glagol --format glagol --print-tree glagol --inspect-lowering=surface glagol --inspect-lowering=checked glagol --check-tests glagol --run-tests glagol test --filter glagol --run-tests --filter ``` CLI behavior: - success writes primary output to stdout and exits `0` - source diagnostics write human and machine diagnostics to stderr and exit `1` - input/read failures exit `1` - usage errors exit `2` - `--help` writes usage information to stderr and exits `0` - experimental exp-7 test filtering selects by case-sensitive test display-name substring, skips non-selected tests before evaluation, and records `total_discovered`, `selected`, `passed`, `failed`, `skipped`, and optional `filter` metadata in test reports/manifests ## Supported Fixture Set Glagol v0 supports these compiler fixtures: ```text examples/add.slo examples/array.slo examples/if.slo examples/local-variables.slo examples/option-result.slo examples/struct.slo examples/unsafe.slo examples/while.slo tests/top-level-test.slo ``` These are aligned with Slovo's `examples/supported/` and `examples/formatter/` fixtures by the ignored monorepo alignment gate. ## Compiler Pipeline The v0 pipeline is: ```text .slo source -> tokens -> S-expression tree -> AST -> typed AST -> LLVM IR text ``` The compiler keeps source-reachable failures diagnostic-first. Checked source forms should not reach backend panics. ## Test Coverage The v0 suite covers: - supported fixture LLVM shape - canonical formatter behavior - parse-tree printing - surface and checked lowering inspection - top-level test checking and running - structured machine diagnostics - source spans and line/column ranges - value-producing `if` - locals and assignment - `while` - structs - arrays and literal indexing - option/result constructors - lexical `unsafe` - CLI usage and exit codes ## Explicit Deferrals Glagol v0 does not implement: - direct executable output - `-o ` - explicit `--emit=llvm` - stdin source input - `--version` - runtime strings - dynamic array indexing and runtime bounds traps - complete struct, array, and option/result value flow - raw memory operations - FFI - stable ABI/layout promises - package management - direct machine-code backend ## Post-v0 Direction Post-v0 work starts in `.llm/V1_ROADMAP.md` and should remain locked to Slovo's `SPEC-v1.md`. The recommended first compiler slice is struct value flow after Slovo specifies the v1 contract for struct locals, parameters, returns, and stored field access.