# Slovo 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 is now documented as an experimental integration/readiness release, not as a beta maturity claim. The current release is `1.0.0-beta.9`, published on 2026-05-22. It keeps the `1.0.0-beta` language surface, includes the first post-beta tooling/install hardening bundle from `1.0.0-beta.1`, and adds the first runtime/resource foundation bundle from `1.0.0-beta.2` plus the first standard-library stabilization bundle from `1.0.0-beta.3`, the first language-usability diagnostics bundle from `1.0.0-beta.4`, and the first local package/workspace discipline bundle from `1.0.0-beta.5`, plus the first loopback networking foundation bundle from `1.0.0-beta.6`, and the first serialization/data-interchange foundation bundle from `1.0.0-beta.7`, and the first concrete type alias foundation from `1.0.0-beta.8`, plus the first collection alias unification and generic reservation slice from `1.0.0-beta.9`. ## Unreleased No unreleased language scope is committed here yet. ## 1.0.0-beta.9 Release label: `1.0.0-beta.9` Release name: Collection Alias Unification And Generic Reservation Release date: 2026-05-22 Status: released beta collection-alias documentation/source update on the `1.0.0-beta` language baseline. `1.0.0-beta.9` applies beta.8 transparent concrete aliases sparingly inside the source-authored collection and value-family facades: - `std.vec_i32`, `std.vec_i64`, `std.vec_f64`, `std.vec_bool`, and `std.vec_string` name their local concrete vector family once and reuse that alias through helper signatures. - `std.option` and `std.result` name the current concrete option/result helper families once and reuse those local aliases through their facade signatures. - Public helper names, imports, exports, constructors, runtime calls, and behavior stay concrete. Cross-module users still see normalized concrete types such as `(vec bool)`, `(option string)`, and `(result u64 i32)`. This release does not add executable generics, generic aliases, parameterized aliases, maps, sets, traits, inference, monomorphization, iterators, new compiler-known runtime names, stable ABI/layout promises, or a stable standard-library API freeze. The generic/map/set direction is reserved for future diagnostics and design work only. ## 1.0.0-beta.8 Release label: `1.0.0-beta.8` Release name: Concrete Type Alias Foundation Release date: 2026-05-22 Status: released beta concrete type alias foundation update on the `1.0.0-beta` language baseline. `1.0.0-beta.8` promotes transparent type aliases for current concrete types: ```slo (type JsonText string) ``` An alias is a module-local source name. It may be used in supported type positions, and the compiler resolves it to the existing concrete target type before backend and ABI behavior. This release does not add generics, parameterized aliases, cross-module alias imports, alias re-exports, maps/sets, stable layout names, new compiler-known runtime names, or runtime changes. - Top-level `(type Alias TargetType)` declarations name existing concrete supported target types without introducing new runtime representations. - Aliases are transparent before typed-core lowering, checked import signatures, backend layout, ABI decisions, and runtime behavior. - The JSON source facade and explicit JSON example projects use local `JsonText` / `JsonField` aliases as narrow source fixtures. - Alias exports, imports, re-exports, cross-module alias visibility, generic aliases, parameterized aliases, maps/sets, and runtime changes remain out of scope. ## 1.0.0-beta.7 Release label: `1.0.0-beta.7` Release name: Serialization And Data Interchange Bundle Release date: 2026-05-22 Status: released beta serialization/data-interchange update on the `1.0.0-beta` language baseline. - `lib/std/json.slo` stages an explicit `std.json` source facade for compact JSON text construction. - The facade wraps the compiler-known `std.json.quote_string` runtime helper and composes it with existing `std.string.concat` and `std.num.*_to_string` helpers for scalar values, fields, small arrays, and small objects. - `examples/projects/std-import-json/` and `examples/projects/std-layout-local-json/` document the explicit import and local source facade shapes. - `benchmarks/json-quote-loop/` adds a local-machine timing scaffold for JSON string quoting across Slovo, C, Rust, Python, Clojure, and Common Lisp/SBCL. 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 name: Networking Foundation Bundle Release date: 2026-05-22 Status: released beta networking foundation update on the `1.0.0-beta` language baseline. - `lib/std/net.slo` stages an explicit `std.net` source facade for blocking loopback TCP only. - The facade wraps the targeted compiler-known calls `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`. - `examples/projects/std-import-net/` and `examples/projects/std-layout-local-net/` document the explicit import and local source facade shapes using deterministic invalid port/handle result checks. This release does not add DNS, TLS, async IO, UDP, non-loopback binding, HTTP frameworks, stable socket ABI/layout, platform-specific error codes, rich host-error ADTs, automatic ownership/finalization, or a stable standard-library API freeze. ## 1.0.0-beta.5 Release label: `1.0.0-beta.5` Release name: Package And Workspace Discipline Bundle Release date: 2026-05-22 Status: released beta package/workspace update on the `1.0.0-beta` language baseline. `1.0.0-beta.5` tightens local workspace behavior without adding a package manager: - Local workspace manifests may now declare `[workspace] default_package = "name"` to make build/run entry selection deterministic when more than one package has an entry module. - Duplicate workspace member paths after normalization are now a dedicated `DuplicateWorkspaceMember` diagnostic. - Missing `default_package` references are now a dedicated `WorkspaceDefaultPackageMissing` diagnostic. A selected default package that lacks its configured entry module is diagnosed as `WorkspaceDefaultPackageEntryMissing` during build/run. - Workspace documentation generated by `glagol doc` now includes a deterministic summary of members, packages, and local dependency edges. - Generated workspace templates and the canonical local workspace examples now declare `default_package = "app"`. - `docs/language/PACKAGES.md` now documents the beta local package/workspace rules and the explicit no-registry/no-lockfile policy. 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 name: Language Usability Diagnostics Bundle Release date: 2026-05-22 Status: released beta diagnostics usability update on the `1.0.0-beta` language baseline. `1.0.0-beta.4` improves diagnostics while keeping the accepted source-language surface unchanged: - project/workspace build and run entry failures now report entry-specific diagnostic codes and spell out the required `(fn main () -> i32 ...)` contract - non-exhaustive `match` diagnostics now use clearer missing-arm wording and a deterministic found-arm list - `.llm/BETA_4_LANGUAGE_USABILITY.md` records the beta.4 usability contract and deferrals This release does not add new syntax, type aliases, argument-taking `main`, `unit`-returning `main`, changed `match` semantics, or stable ABI/layout guarantees. ## 1.0.0-beta.3 Release label: `1.0.0-beta.3` Release name: Standard Library Stabilization Bundle Release date: 2026-05-22 Status: released beta standard-library stabilization update on the `1.0.0-beta` language baseline. `1.0.0-beta.3` contains the first standard-library stabilization slice: - `docs/language/STDLIB_API.md` is generated from the exported helpers in `lib/std/*.slo` - `scripts/render-stdlib-api-doc.sh` regenerates that catalog, and `scripts/release-gate.sh` fails if the generated catalog is stale - `examples/projects/stdlib-composition` adds a realistic command-line project that composes explicit `std.fs`, `std.string`, `std.math`, and `std.io` imports for file write/read, parse, compute, cleanup, and hosted run output - `.llm/BETA_3_STDLIB_STABILIZATION.md` records the beta.3 stabilization contract and deferred decisions This release does not freeze stable standard-library APIs. It still defers generics, an automatic prelude, stable ABI/layout guarantees, richer host error codes, maps/sets, networking, and async behavior. ## 1.0.0-beta.2 Release label: `1.0.0-beta.2` Release name: Runtime Resource Foundation Bundle Release date: 2026-05-22 Status: released beta runtime/resource foundation update on the `1.0.0-beta` language baseline. `1.0.0-beta.2` contains the first runtime/resource foundation slice: - `std.fs.open_text_read_result : (string) -> (result i32 i32)` opens a read-only text file and returns an opaque positive `i32` handle - `std.fs.read_open_text_result : (i32) -> (result string i32)` reads remaining text from an open read handle - `std.fs.close_result : (i32) -> (result i32 i32)` closes an open handle - `std.fs.exists : (string) -> bool`, `std.fs.is_file : (string) -> bool`, and `std.fs.is_dir : (string) -> bool` expose narrow filesystem status checks - `std.fs.remove_file_result : (string) -> (result i32 i32)` removes a file and `std.fs.create_dir_result : (string) -> (result i32 i32)` creates one directory, both returning `ok 0` or `err 1` - `lib/std/fs.slo` wraps those calls with explicit source facades `open_text_read_result`, `read_open_text_result`, `close_result`, `read_text_via_handle_result`, `close_ok`, status helpers, and narrow file/directory mutation helpers This release keeps handles beta-scoped. It does not add writable handles, binary IO, directory handles, directory enumeration, recursive filesystem operations, process handles, sockets, async IO, platform error codes, rich host-error ADTs, or stable handle ABI/layout promises. ## 1.0.0-beta.1 Release label: `1.0.0-beta.1` Release name: First Post-Beta Tooling Hardening Bundle Release date: 2026-05-22 Status: released beta tooling update on the `1.0.0-beta` language baseline. `1.0.0-beta.1` contains tooling hardening only: - `glagol run ` builds and executes through the hosted native toolchain using `.slovo/build` when `-o` is not provided - `glagol clean ` removes generated `.slovo/build` artifacts - `glagol new --template binary|library|workspace` scaffolds binary projects, library projects, and local package workspaces using existing manifest rules - `scripts/install.sh` installs the compiler, `lib/std`, and runtime C input under a configurable prefix - installed `glagol` discovers `share/slovo/std` and `share/slovo/runtime/runtime.c` relative to its executable, with environment overrides still available - the release gate prints a concise final success line after all checks pass This beta.1 slice does not add source-language syntax, stable ABI/layout guarantees, networking, package registry behavior, or a stable standard-library freeze. ## 1.0.0-beta Release label: `1.0.0-beta` Release name: First Real General-Purpose Beta Release date: 2026-05-21 Status: released beta language contract. The normative Slovo-side beta contract is `.llm/V1_0_0_BETA.md`. `1.0.0-beta` includes: - `i32`, `i64`, `u32`, `u64`, `f64`, `bool`, and `string` - current fixed immutable arrays, current concrete vector families, structs, enums, option/result, and lexical `unsafe` gating - explicit `std/*.slo` imports for strings, numerics, IO, CLI, process args, env, text FS, time, randomness, result/option, and concrete vectors - local packages, workspaces, deterministic dependency handling, generated docs, formatter modes, JSON diagnostics, and the paired local release gate `1.0.0-beta` still defers generics, maps/sets, remote registries, networking/async, and stable ABI/layout/ownership guarantees. ## exp-125 (final experimental precursor scope) Release label: `exp-125` Release name: Unsigned U32 U64 Numeric And Stdlib Breadth Alpha Target date: 2026-05-21 Status: completed experimental precursor scope absorbed into `1.0.0-beta`. The normative Slovo-side contract target is `.llm/EXP_125_UNSIGNED_U32_U64_NUMERIC_AND_STDLIB_BREADTH_ALPHA.md`. exp-125 broadens the numeric and staged stdlib surface with one connected unsigned scope: - direct `u32` and `u64` value flow - decimal suffixed literals `42u32` and `42u64` - same-type unsigned arithmetic and comparison - compiler-known `std.io.print_u32`, `std.io.print_u64`, `std.num.u32_to_string`, `std.num.u64_to_string`, `std.string.parse_u32_result`, and `std.string.parse_u64_result` - source helper parity across `std.result`, `std.option`, `std.string`, `std.num`, `std.io`, `std.env`, `std.fs`, `std.process`, and `std.cli` The matching Slovo-side fixtures include `examples/supported/u32-numeric-primitive.slo`, `examples/supported/u64-numeric-primitive.slo`, `examples/supported/unsigned-integer-to-string.slo`, `examples/supported/string-parse-u32-result.slo`, `examples/supported/string-parse-u64-result.slo`, their formatter mirrors, and the widened explicit import fixtures under `examples/projects/std-import-*`. exp-125 itself did not claim beta maturity, implicit numeric promotion, mixed signed/unsigned arithmetic, broader cast families, unsigned widths beyond `u32`/`u64`, generic numeric helpers, unsigned collections, unsigned enum payloads or struct fields, stable ABI/layout/ownership, or released compiler support before the sibling Glagol work landed. ## exp-124 (released experimental alpha) Release label: `exp-124` Release name: Fixed Array Enum And Struct Elements Alpha Release date: 2026-05-21 Status: released experimental alpha language contract, not beta. The normative Slovo-side contract target is `.llm/EXP_124_FIXED_ARRAY_ENUM_AND_STRUCT_ELEMENTS_ALPHA.md`. exp-124 broadens the fixed immutable array surface with two connected element lanes: - direct known enum elements - current known non-recursive struct elements The release promotes immutable locals, parameters, returns, calls returning arrays, and checked `i32` indexing over those new element families. It adds `examples/supported/array-enum.slo`, `examples/formatter/array-enum.slo`, `examples/supported/array-struct-elements.slo`, and `examples/formatter/array-struct-elements.slo`. exp-124 does not add zero-length arrays, mutable arrays, element mutation, array equality, array printing, nested arrays, slices, generics, stable ABI/layout/ownership claims, or beta maturity. ## exp-123 (released experimental alpha) Release label: `exp-123` Release name: Owned Vector Benchmark Suite Extension And Whitepaper Refresh Alpha Release date: 2026-05-21 Status: released experimental alpha documentation/tooling contract, not beta. The normative Slovo-side contract target is `.llm/EXP_123_OWNED_VECTOR_BENCHMARK_SUITE_EXTENSION_AND_WHITEPAPER_REFRESH_ALPHA.md`. exp-123 keeps the exp-121 language surface unchanged and refreshes the current publication baseline around one connected benchmark/documentation scope: - `docs/SLOVO_WHITEPAPER.md` refreshed from the earlier exp-122 publication framing to the current language/tooling state through exp-121 - benchmark methodology widened from seven kernels to nine: `math-loop`, `branch-loop`, `parse-loop`, `array-index-loop`, `string-eq-loop`, `array-struct-field-loop`, `enum-struct-payload-loop`, `vec-i32-index-loop`, and `vec-string-eq-loop` - paired same-machine benchmark refresh targets widened from seven rows to nine rows for the controller-owned publication pass - local-machine-only wording, no threshold claim, and no cross-machine claim retained - `docs/README.md`, README release metadata, and spec/roadmap wording aligned to the refreshed publication baseline The matching publication artifacts remain `docs/SLOVO_WHITEPAPER.pdf` and `WHITEPAPER.pdf`, regenerated after the paired controller-side benchmark data refresh and release publication pass. exp-123 does not add new source syntax, type forms, standard-library APIs, compiler-known runtime names, optimizer guarantees, benchmark thresholds, cross-machine performance claims, stable ABI/layout/ownership claims, or beta maturity. ## exp-122 (released experimental alpha) Release label: `exp-122` Release name: Composite Data Benchmark Suite Extension And Whitepaper Refresh Alpha Release date: 2026-05-21 Status: released experimental alpha documentation/tooling contract, not beta. The normative Slovo-side contract target is `.llm/EXP_122_COMPOSITE_DATA_BENCHMARK_SUITE_EXTENSION_AND_WHITEPAPER_REFRESH_ALPHA.md`. exp-122 keeps the exp-121 language surface unchanged and refreshes the current publication baseline around one connected benchmark/documentation scope: - `docs/SLOVO_WHITEPAPER.md` refreshed from the earlier exp-119 publication framing to the current language/tooling state through exp-121 - benchmark methodology widened from five kernels to seven: `math-loop`, `branch-loop`, `parse-loop`, `array-index-loop`, `string-eq-loop`, `array-struct-field-loop`, and `enum-struct-payload-loop` - paired same-machine benchmark refresh targets widened from five rows to seven rows for the controller-owned publication pass - local-machine-only wording, no threshold claim, and no cross-machine claim retained - `docs/README.md`, README release metadata, and spec/roadmap wording aligned to the refreshed publication baseline The matching publication artifacts remain `docs/SLOVO_WHITEPAPER.pdf` and `WHITEPAPER.pdf`, regenerated after the paired controller-side benchmark data refresh and release publication pass. exp-122 does not add new source syntax, type forms, standard-library APIs, compiler-known runtime names, optimizer guarantees, benchmark thresholds, cross-machine performance claims, stable ABI/layout/ownership claims, or beta maturity. ## exp-121 (released experimental alpha) Release label: `exp-121` Release name: Non-Recursive Struct Enum Payloads Alpha Release date: 2026-05-21 Status: released experimental alpha language contract, not beta. The normative Slovo-side contract target is `.llm/EXP_121_NON_RECURSIVE_STRUCT_ENUM_PAYLOADS_ALPHA.md`. exp-121 broadens the enum payload surface with one connected struct-payload scope: - unary enum payload variants may use current known non-recursive struct types - payload variants in one enum still share the same payload type when payload variants are present - qualified payload constructors over those struct types - immutable enum locals, parameters, returns, calls, tests, and `main` - exhaustive `match` with one immutable payload binding - existing field access behavior on bound struct payloads, including array field access and checked indexing where already promoted by exp-120 The matching supported and formatter fixtures are `examples/supported/enum-payload-structs.slo` and `examples/formatter/enum-payload-structs.slo`. exp-121 does not add enum equality requirements for struct-payload enums, direct array/vec/option/result payloads, multiple payload fields, recursive/cyclic payloads, mutation, generics, stable ABI/layout/ownership claims, or beta maturity. ## exp-120 (released experimental alpha) Release label: `exp-120` Release name: Fixed Array Struct Fields Alpha Release date: 2026-05-21 Status: released experimental alpha language contract, not beta. The normative Slovo-side contract target is `.llm/EXP_120_FIXED_ARRAY_STRUCT_FIELDS_ALPHA.md`. exp-120 broadens the struct-field surface with one connected fixed-array scope: - direct struct field declarations over `(array i32 N)`, `(array i64 N)`, `(array f64 N)`, `(array bool N)`, and `(array string N)` - struct construction from matching fixed-array expressions - immutable struct locals initialized from matching struct-valued expressions - struct parameters and returns for structs carrying those field types - calls returning structs carrying those field types - field access returning the declared fixed-array type - checked indexing through field access with `i32` expressions only The matching supported and formatter fixtures are `examples/supported/array-struct-fields.slo` and `examples/formatter/array-struct-fields.slo`. The earlier `array*` fixtures remain valid as the underlying fixed-array lanes. The earlier `enum-struct-fields.slo`, `primitive-struct-fields.slo`, `numeric-struct-fields.slo`, and `composite-struct-fields.slo` fixtures remain valid as narrower or sibling struct-field lanes. exp-120 does not add zero-length arrays, mutable arrays, element mutation, field mutation, array equality, array printing, nested arrays, arrays of unsupported element kinds, arrays inside unsupported containers, slices, generics, stable ABI/layout/ownership claims, or beta maturity. ## exp-119 (released experimental alpha) Release label: `exp-119` Release name: Benchmark Suite Extension And Whitepaper Refresh Alpha Release date: 2026-05-21 Status: released experimental alpha documentation/tooling contract, not beta. The normative Slovo-side contract target is `.llm/EXP_119_BENCHMARK_SUITE_EXTENSION_AND_WHITEPAPER_REFRESH_ALPHA.md`. exp-119 keeps the exp-118 language surface unchanged and refreshes the current publication baseline around one connected benchmark/documentation scope: - `docs/SLOVO_WHITEPAPER.md` refreshed from the older exp-59 framing to the current language/tooling state through exp-118 - benchmark methodology widened from three kernels to five: `math-loop`, `branch-loop`, `parse-loop`, `array-index-loop`, and `string-eq-loop` - benchmark result tables widened from three rows to five rows for paired same-machine publication refresh - local-machine-only wording, no threshold claim, and no cross-machine claim retained - `docs/README.md`, release metadata, and spec/roadmap wording aligned to the refreshed publication baseline The matching publication artifacts remain `docs/SLOVO_WHITEPAPER.pdf` and `WHITEPAPER.pdf`, regenerated after the paired controller-side benchmark data refresh and release publication pass. exp-119 does not add new source syntax, type forms, standard-library APIs, compiler-known runtime names, optimizer guarantees, benchmark thresholds, cross-machine performance claims, stable ABI/layout/ownership claims, or beta maturity. ## exp-118 (released experimental alpha) Release label: `exp-118` Release name: String Fixed Arrays Alpha Release date: 2026-05-21 Status: released experimental alpha language contract, not beta. The normative Slovo-side contract target is `.llm/EXP_118_STRING_FIXED_ARRAYS_ALPHA.md`. exp-118 broadens the fixed-array surface with one connected string-array scope: - fixed array types over `string` - positive literal lengths only - direct array constructors over `string` - immutable array locals initialized from matching array-valued expressions - fixed-array parameters and returns over `string` - calls returning arrays over `string` - checked literal indexing and runtime-checked dynamic indexing - `i32` index expressions only The matching supported and formatter fixtures are `examples/supported/array-string.slo`, `examples/formatter/array-string.slo`, `examples/supported/array-string-value-flow.slo`, and `examples/formatter/array-string-value-flow.slo`. The earlier `examples/supported/array.slo` and `examples/supported/array-value-flow.slo` fixtures remain valid as narrower `i32`-only predecessors. The earlier `array-direct-scalars*` fixtures remain valid as the direct scalar widening lane from exp-117. exp-118 does not add zero-length arrays, mutable arrays, element mutation, array equality, printing arrays, nested arrays, arrays in struct fields, arrays of other unsupported element types, slices, generics, stable ABI/layout/ownership claims for string elements, or beta maturity. ## exp-117 (released experimental alpha) Release label: `exp-117` Release name: Direct Scalar Fixed Arrays Alpha Release date: 2026-05-21 Status: released experimental alpha language contract, not beta. The normative Slovo-side contract target is `.llm/EXP_117_DIRECT_SCALAR_FIXED_ARRAYS_ALPHA.md`. exp-117 broadens the fixed-array surface with one connected direct-scalar scope: - fixed array types over `i32`, `i64`, `f64`, and `bool` - positive literal lengths only - direct array constructors over those element families - immutable array locals initialized from matching array-valued expressions - fixed-array parameters and returns over those element families - calls returning arrays over those element families - checked literal indexing and runtime-checked dynamic indexing - `i32` index expressions only The matching supported and formatter fixtures are `examples/supported/array-direct-scalars.slo`, `examples/formatter/array-direct-scalars.slo`, `examples/supported/array-direct-scalars-value-flow.slo`, and `examples/formatter/array-direct-scalars-value-flow.slo`. The earlier `examples/supported/array.slo` and `examples/supported/array-value-flow.slo` fixtures remain valid as narrower `i32`-only predecessors. exp-117 does not add zero-length arrays, mutable arrays, element mutation, array equality, printing arrays, nested arrays, arrays in struct fields, string arrays, arrays of other unsupported element types, slices, generics, stable ABI/layout claims, or beta maturity. ## exp-116 (released experimental alpha) Release label: `exp-116` Release name: Direct Scalar And String Enum Payloads Alpha Release date: 2026-05-21 Status: released experimental alpha language contract, not beta. The normative Slovo-side contract target is `.llm/EXP_116_DIRECT_SCALAR_AND_STRING_ENUM_PAYLOADS_ALPHA.md`. exp-116 broadens the user-defined enum payload surface with one connected direct-payload scope: - payloadless variants remain supported - unary `(Variant i32)` payload variants remain supported - unary direct `(Variant i64)` payload variants - unary direct `(Variant f64)` payload variants - unary direct `(Variant bool)` payload variants - unary direct `(Variant string)` payload variants - qualified zero-argument payloadless constructors and qualified one-argument payload constructors - immutable enum locals, parameters, returns, calls, top-level tests, and `main` - exhaustive enum `match` with one immutable arm-local payload binding for payload variants - same-enum equality by tag for payloadless variants and by tag plus payload for unary direct payload variants The matching supported and formatter fixtures are `examples/supported/enum-payload-direct-scalars.slo` and `examples/formatter/enum-payload-direct-scalars.slo`. exp-116 does not add mixed payload kinds inside one enum, multiple payloads, record variants, tuple variants beyond one direct payload, vec/array/option/ result/struct/enum payloads, enum mutation, richer pattern families, generic enums, methods, traits, new compiler-known runtime names, manifest schema changes, or beta maturity. ## exp-115 (released experimental alpha) Release label: `exp-115` Release name: Composite Struct Fields And Nested Structs Alpha Release date: 2026-05-21 Status: released experimental alpha language contract, not beta. The normative Slovo-side contract target is `.llm/EXP_115_COMPOSITE_STRUCT_FIELDS_AND_NESTED_STRUCTS_ALPHA.md`. exp-115 broadens the struct-field surface with one connected composite-field scope: - direct struct fields over `(vec i32)`, `(vec i64)`, `(vec f64)`, `(vec bool)`, and `(vec string)` - direct struct fields over `(option i32)`, `(option i64)`, `(option f64)`, `(option bool)`, and `(option string)` - direct struct fields over `(result i32 i32)`, `(result i64 i32)`, `(result f64 i32)`, `(result bool i32)`, and `(result string i32)` - direct struct fields over current known non-recursive struct types - coexistence with the already supported direct scalar, immutable string, and current enum field families - immutable struct locals, parameters, returns, calls, top-level tests, and `main` for structs carrying those fields The matching supported and formatter fixtures are `examples/supported/composite-struct-fields.slo` and `examples/formatter/composite-struct-fields.slo`. exp-115 does not add arrays as struct fields, mutable arrays, field mutation, vector element mutation, option/result payload mutation, enum payload mutation, recursive or cyclic struct layouts, new compiler-known runtime names, manifest schema changes, or beta maturity. ## exp-114 (released experimental alpha) Release label: `exp-114` Release name: Mutable Composite Locals Alpha Release date: 2026-05-21 Status: released experimental alpha language contract, not beta. The normative Slovo-side contract target is `.llm/EXP_114_MUTABLE_COMPOSITE_LOCALS_ALPHA.md`. exp-114 broadens the local-value surface with one connected mutable-composite scope: - same-type mutable whole-value `var` / `set` reassignment for `string` - same-type mutable whole-value `var` / `set` reassignment for `(vec i32)`, `(vec i64)`, `(vec f64)`, `(vec bool)`, and `(vec string)` - same-type mutable whole-value `var` / `set` reassignment for current concrete option/result families - same-type mutable whole-value `var` / `set` reassignment for current known struct values and current enum values - ordinary function bodies, top-level tests, and `main` The matching supported and formatter fixtures are `examples/supported/composite-locals.slo` and `examples/formatter/composite-locals.slo`. exp-114 does not add array mutation or mutable arrays, field mutation, vector element mutation, option/result payload mutation, enum payload mutation, mixed-type assignment, new compiler-known runtime names, manifest schema changes, or beta maturity. ## exp-113 (released experimental alpha) Release label: `exp-113` Release name: Mutable Scalar Locals Alpha Release date: 2026-05-21 Status: released experimental alpha language contract, not beta. The normative Slovo-side contract target is `.llm/EXP_113_MUTABLE_SCALAR_LOCALS_ALPHA.md`. exp-113 broadens the local-value surface with one connected mutable-scalar scope: - direct mutable `var` locals declared as `bool`, `i64`, and `f64` - same-type `set` reassignment from already promoted scalar expressions for those declared local types - ordinary function bodies, top-level tests, and `main` The matching supported and formatter fixtures remain `examples/supported/local-variables.slo` and `examples/formatter/local-variables.slo`, now broadened to include mutable `bool`, `i64`, and `f64` local var/set flows alongside the earlier i32 local forms and exp-112 immutable bool locals. exp-113 does not add mutable `string` locals, vector mutation, option/result mutation, struct or enum mutation, mixed-type assignment, new compiler-known runtime names, manifest schema changes, or beta maturity. ## exp-112 (released experimental alpha) Release label: `exp-112` Release name: Immutable Bool Locals Alpha Release date: 2026-05-21 Status: released experimental alpha language contract, not beta. The normative Slovo-side contract target is `.llm/EXP_112_IMMUTABLE_BOOL_LOCALS_ALPHA.md`. exp-112 broadens the local-value surface with one connected immutable-bool scope: - direct immutable `let` locals declared as `bool` - local initializers from already promoted bool literals, parameters, calls returning bool, and `if` expressions returning bool - local references in existing predicate, return, call, top-level test, and `main` positions The matching supported and formatter fixtures remain `examples/supported/local-variables.slo` and `examples/formatter/local-variables.slo`, now broadened to include direct immutable bool locals alongside the earlier i32 local forms. The current `examples/projects/std-import-io/` explicit import fixture also now uses direct bool locals in its stdin bool-fallback helper path. exp-112 does not add mutable bool locals, bool assignment, `var bool`, new boolean operators, broader local-type widening, new compiler-known runtime names, manifest schema changes, or beta maturity. ## exp-111 (released experimental alpha) Release label: `exp-111` Release name: Standard IO Stdin Source Helpers Alpha Release date: 2026-05-21 Status: released experimental alpha stdlib/source contract, not beta. The normative Slovo-side contract target is `.llm/EXP_111_STANDARD_IO_STDIN_SOURCE_HELPERS_ALPHA.md`. exp-111 broadens `std/io.slo` with one connected stdin helper package: - `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 existing zero-returning and value-returning print helper surfaces remain in place. All new helpers remain ordinary Slovo source over the already promoted `std.io.read_stdin_result`, the released `std.string.parse_*_result` helpers, and the exp-109 `std.result.ok_or_none_*` bridge helpers. The scope adds no new compiler-known `std.*` names, no generics, and no new runtime calls. The matching explicit import fixture `examples/projects/std-import-io/` now exercises the expanded stdin helper lane structurally instead of assuming a fixed runner stdin payload. exp-111 does not add trap-based `std.io.read_stdin`, line/read-line APIs, prompt APIs, terminal mode, binary stdin, streaming stdin, async IO, generics, compiler-known `std.*` runtime names beyond the already released lane, or beta maturity. ## exp-110 (released experimental alpha) Release label: `exp-110` Release name: Standard String, Env, Fs, Process, And Cli Option Helpers Alpha Release date: 2026-05-21 Status: released experimental alpha stdlib/source contract, not beta. The normative Slovo-side contract target is `.llm/EXP_110_STANDARD_STRING_ENV_FS_PROCESS_AND_CLI_OPTION_HELPERS_ALPHA.md`. exp-110 broadens `std/string.slo`, `std/env.slo`, `std/fs.slo`, `std/process.slo`, and `std/cli.slo` with one connected option-helper package: - `std.string`: `parse_i32_option`, `parse_i64_option`, `parse_f64_option`, `parse_bool_option` - `std.env`: `get_option`, `get_i32_option`, `get_i64_option`, `get_f64_option`, `get_bool_option` - `std.fs`: `read_text_option`, `read_i32_option`, `read_i64_option`, `read_f64_option`, `read_bool_option` - `std.process`: `arg_option`, `arg_i32_option`, `arg_i64_option`, `arg_f64_option`, `arg_bool_option` - `std.cli`: `arg_text_option`, `arg_i32_option`, `arg_i64_option`, `arg_f64_option`, `arg_bool_option` The existing direct/result/fallback helper surfaces remain in place for all five staged modules. All new helpers remain ordinary Slovo source over the existing concrete result lanes through the exp-109 `std.result.ok_or_none_*` bridge helpers. The scope adds no new compiler-known `std.*` names, no generics, no new runtime calls, no stdin helpers, and no vec work. The matching explicit import fixtures, `examples/projects/std-import-string/`, `examples/projects/std-import-env/`, `examples/projects/std-import-fs/`, `examples/projects/std-import-process/`, and `examples/projects/std-import-cli/`, now deterministically exercise the new option helpers alongside the earlier result and fallback lanes. exp-110 does not add generic option/result combinators, automatic or compiler-loaded std imports, stable ABI/layout claims, or beta maturity. ## exp-109 (released experimental alpha) Release label: `exp-109` Release name: Standard Option And Result Bridge Helpers Alpha Release date: 2026-05-21 Status: released experimental alpha stdlib/source contract, not beta. The normative Slovo-side contract target is `.llm/EXP_109_STANDARD_OPTION_AND_RESULT_BRIDGE_HELPERS_ALPHA.md`. exp-109 broadens `std/option.slo` and `std/result.slo` with one connected bridge-helper package between the current concrete option and result families: - `std/option.slo`: `some_or_err_i32`, `some_or_err_i64`, `some_or_err_f64`, `some_or_err_bool`, `some_or_err_string` - `std/result.slo`: `ok_or_none_i32`, `ok_or_none_i64`, `ok_or_none_string`, `ok_or_none_f64`, `ok_or_none_bool` The existing concrete constructor, observer, unwrap, and fallback helpers remain in place for both staged modules. All new helpers remain ordinary Slovo source. `some_or_err_*` uses the existing raw `is_some`, `unwrap_some`, `ok`, and `err` forms to produce `(result i32)` without importing `std.result`. `ok_or_none_*` uses the existing `std.result.is_ok`, `std.result.unwrap_ok`, `some`, and `none` forms to produce `(option )` without importing `std.option`. The matching explicit import fixtures, `examples/projects/std-import-option/`, `examples/workspaces/std-import-option/`, and `examples/projects/std-import-result/`, now deterministically exercise the new bridge helpers alongside the earlier concrete helper surfaces. The project option fixture now passes 26 deterministic tests, the workspace option fixture passes 1 deterministic test, and the project result fixture passes 18 deterministic tests. exp-109 does not add compiler-known `std.*` names, generic bridge helpers, generic `map`/`and_then`/`transpose`/`flatten`, new payload families, automatic or compiler-loaded std imports, stable ABI/layout claims, or beta maturity. ## exp-108 (released experimental alpha) Release label: `exp-108` Release name: Standard Vec String, F64, And Bool Prefix And Suffix Helpers Alpha Release date: 2026-05-21 Status: released experimental alpha stdlib/source contract, not beta. The normative Slovo-side contract target is `.llm/EXP_108_STANDARD_VEC_STRING_F64_AND_BOOL_PREFIX_AND_SUFFIX_HELPERS_ALPHA.md`. exp-108 broadens `std/vec_string.slo`, `std/vec_f64.slo`, and `std/vec_bool.slo` from their released edit baselines with one connected immutable prefix/suffix package: - `starts_with` - `without_prefix` - `ends_with` - `without_suffix` The baseline direct wrappers, builder helpers, query helpers, option-query helpers, transform helpers, subvec helper, edit helpers, and simple real-program helpers remain in place for the three concrete vec families. All new helpers remain ordinary Slovo source over the four already released runtime calls for each family plus existing helper composition. Empty prefixes and suffixes behave as identity boundaries, exact whole-vector prefix/suffix matches collapse to `empty`, and mismatched prefixes or suffixes leave the input vector unchanged for the corresponding `without_prefix` or `without_suffix` call. The matching explicit import fixtures, `examples/projects/std-import-vec_string/`, `examples/projects/std-import-vec_f64/`, and `examples/projects/std-import-vec_bool/`, now deterministically exercise the baseline, option-query, prefix/suffix, transform, subvec, edit, and real-program helper groups through explicit imports. Each project now passes 19 deterministic fixture tests. exp-108 does not add compiler-known `std.*` names beyond the already released vec-string, vec-f64, and vec-bool runtime families, generics, sorting, mapping, filtering, nested/container vecs, mutating/capacity APIs, automatic or compiler-loaded std imports, stable ABI/layout claims, or beta maturity. ## exp-107 (released experimental alpha) Release label: `exp-107` Release name: Standard Vec String, F64, And Bool Edit Helpers Alpha Release date: 2026-05-21 Status: released experimental alpha stdlib/source contract, not beta. The normative Slovo-side contract target is `.llm/EXP_107_STANDARD_VEC_STRING_F64_AND_BOOL_EDIT_HELPERS_ALPHA.md`. exp-107 broadens `std/vec_string.slo`, `std/vec_f64.slo`, and `std/vec_bool.slo` from their released option-query and transform baselines with one connected immutable edit package: - `insert_at` - `insert_range` - `replace_at` - `replace_range` - `remove_at` - `remove_range` The baseline direct wrappers, builder helpers, query helpers, option-query helpers, transform helpers, subvec helper, and simple real-program helpers remain in place for the three concrete vec families. All new helpers remain ordinary Slovo source over the four already released runtime calls for each family plus existing helper composition. `insert_at` appends on exact-length positions and otherwise leaves invalid negative or past-end positions unchanged; `insert_range` behaves the same for whole-vector insertion; `replace_at` changes one in-range position or returns the original vector; `replace_range` replaces a half-open in-range segment with tail saturation; `remove_at` removes one in-range position or returns the original vector; and `remove_range` removes a half-open in-range segment with tail saturation. The matching explicit import fixtures, `examples/projects/std-import-vec_string/`, `examples/projects/std-import-vec_f64/`, and `examples/projects/std-import-vec_bool/`, now deterministically exercise the baseline, option-query, transform, subvec, edit, and real-program helper groups through explicit imports. Each project now passes 15 deterministic fixture tests. exp-107 does not add compiler-known `std.*` names beyond the already released vec-string, vec-f64, and vec-bool runtime families, generics, prefix/suffix helpers, sorting, mapping, filtering, nested/container vecs, mutating/capacity APIs, automatic or compiler-loaded std imports, stable ABI/layout claims, or beta maturity. ## exp-106 (released experimental alpha) Release label: `exp-106` Release name: Standard Vec F64 And Bool Option Query Helpers Alpha Release date: 2026-05-21 Status: released experimental alpha stdlib/source contract, not beta. The normative Slovo-side contract target is `.llm/EXP_106_STANDARD_VEC_F64_AND_BOOL_OPTION_QUERY_HELPERS_ALPHA.md`. exp-106 broadens `std/vec_f64.slo` and `std/vec_bool.slo` from their released transform baselines with one connected option-query package: - `index_option` - `first_option` - `last_option` - `index_of_option` - `last_index_of_option` The baseline direct wrappers, builder helpers, query helpers, transform helpers, subvec helper, and simple real-program helpers remain in place for both concrete vec families. All new helpers remain ordinary Slovo source over the four already released runtime calls for each family and the already promoted concrete option families they return. `index_option` returns `none` for negative and out-of-range positions; `first_option` delegates to `index_option values 0`; `last_option` returns `none` for empty vectors and `some` of the last element otherwise; `index_of_option` returns the first matching position or `none`; and `last_index_of_option` returns the last matching position or `none`. The matching explicit import fixtures, `examples/projects/std-import-vec_f64/` and `examples/projects/std-import-vec_bool/`, now deterministically exercise the baseline, option-query, transform, subvec, and real-program helper groups through explicit `(import std.vec_f64 (...))` and `(import std.vec_bool (...))`. Each project now passes 9 deterministic fixture tests. exp-106 does not add compiler-known `std.*` names beyond the already released vec-f64 and vec-bool runtime families, generics, edit helpers, nested/container vecs, mutating/capacity APIs, automatic or compiler-loaded std imports, stable ABI/layout claims, or beta maturity. ## exp-105 (released experimental alpha) Release label: `exp-105` Release name: Standard Vec F64 And Bool Transform Helpers Alpha Release date: 2026-05-21 Status: released experimental alpha stdlib/source contract, not beta. The normative Slovo-side contract target is `.llm/EXP_105_STANDARD_VEC_F64_AND_BOOL_TRANSFORM_HELPERS_ALPHA.md`. exp-105 broadens `std/vec_f64.slo` and `std/vec_bool.slo` from their released baselines with one connected transform-helper package: - `concat` - `take` - `drop` - `reverse` - `subvec` The baseline direct wrappers, builder helpers, query helpers, and simple real-program helpers remain in place for both concrete vec families. All new helpers remain ordinary Slovo source over the four already released runtime calls for each family. `take` treats negative counts as zero and saturates to the full source vector, `drop` treats negative counts as zero and saturates at the source tail, `reverse` returns a copied reverse-order vector, and `subvec` returns a copied half-open range or `empty` for negative or empty starts. The matching explicit import fixtures, `examples/projects/std-import-vec_f64/` and `examples/projects/std-import-vec_bool/`, now deterministically exercise the baseline, transform, subvec, and real-program helper groups through explicit `(import std.vec_f64 (...))` and `(import std.vec_bool (...))`. Each project now passes 8 deterministic fixture tests. exp-105 does not add compiler-known `std.*` names beyond the already released vec-f64 and vec-bool runtime families, generics, option/result helpers, edit helpers, nested/container vecs, mutating/capacity APIs, automatic or compiler-loaded std imports, stable ABI/layout claims, or beta maturity. ## exp-104 (released experimental alpha) Release label: `exp-104` Release name: Standard Vec Bool Baseline Alpha Release date: 2026-05-21 Status: released experimental alpha stdlib/source contract, not beta. The normative Slovo-side contract target is `.llm/EXP_104_STANDARD_VEC_BOOL_BASELINE_ALPHA.md`. exp-104 stages `std/vec_bool.slo` as the first source-authored `(vec bool)` facade over the sibling concrete `std.vec.bool` runtime family. The frozen source helper surface is: - direct wrappers: `empty`, `append`, `len`, `at` - builder helpers: `singleton`, `append2`, `append3`, `pair`, `triple` - query helpers: `is_empty`, `index_or`, `first_or`, `last_or` - simple real-program helpers: `contains`, `count_of` All helpers remain ordinary Slovo source over the four released vec-bool runtime calls. `index_or` returns its fallback for negative and out-of-range positions, `first_or` delegates to `index_or values 0 fallback`, `last_or` returns its fallback for empty vectors and the final element otherwise, `contains` returns `true` exactly when some element equals the target, and `count_of` returns `0` for empty vectors and counts repeated matches exactly. The matching explicit import fixture, `examples/projects/std-import-vec_bool/`, freezes deterministic direct, builder, query, and real-program helper coverage through explicit `(import std.vec_bool (...))`. The matching supported and formatter fixtures, `examples/supported/vec-bool.slo` and `examples/formatter/vec-bool.slo`, exercise the intended raw `std.vec.bool.*` runtime surface, append immutability, concrete `(vec bool)` flow, and same-family vector equality on the Slovo side. exp-104 does not add compiler-known `std.*` names beyond the released vec-bool runtime family, generics, option/result helpers, transform/range/edit helpers, nested/container vecs, mutating/capacity APIs, automatic or compiler-loaded std imports, stable ABI/layout claims, or beta maturity. ## exp-103 (released experimental alpha) Release label: `exp-103` Release name: Standard Vec F64 Baseline Alpha Release date: 2026-05-21 Status: released experimental alpha stdlib/source contract plus concrete vector-family contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_103_STANDARD_VEC_F64_BASELINE_ALPHA.md`. exp-103 adds `std/vec_f64.slo` as the first usable source-authored `(vec f64)` facade over the sibling concrete `std.vec.f64` runtime family. The staged source helper surface is: - direct wrappers: `empty`, `append`, `len`, `at` - builder helpers: `singleton`, `append2`, `append3`, `pair`, `triple` - query helpers: `is_empty`, `index_or`, `first_or`, `last_or` - simple real-program helpers: `contains`, `sum` All helpers remain ordinary Slovo source over the four promoted vec-f64 runtime calls. `index_or` returns its fallback for negative and out-of-range positions, `first_or` delegates to `index_or values 0 fallback`, `last_or` returns its fallback for empty vectors and the final element otherwise, `contains` returns `true` exactly when some element equals the target, and `sum` returns `0.0` for empty vectors. The matching explicit import fixture, `examples/projects/std-import-vec_f64/`, deterministically exercises the direct wrappers, builder helpers, query helpers, and real-program helpers through explicit `(import std.vec_f64 (...))`. The matching supported and formatter fixtures, `examples/supported/vec-f64.slo` and `examples/formatter/vec-f64.slo`, exercise the compiler-known `std.vec.f64.*` runtime surface, append immutability, concrete `(vec f64)` flow, and same-family vector equality. exp-103 does not add compiler-known `std.*` names beyond the vec-f64 runtime family, generics, option-query helpers, transform/range/edit helpers, nested/container vecs, automatic or compiler-loaded std imports, stable ABI/layout claims, or beta maturity. ## exp-102 (released experimental alpha) Release label: `exp-102` Release name: Standard Option Bool And F64 Baseline Alpha Release date: 2026-05-21 Status: released experimental alpha source/core-language contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_102_STANDARD_OPTION_BOOL_AND_F64_BASELINE_ALPHA.md`. exp-102 broadens the staged `std/option.slo` helper surface and the current core-language option slice from concrete `(option i32)`, `(option i64)`, and `(option string)` to those families plus concrete `(option f64)` and `(option bool)`. The staged source helper surface is now: - `(option i32)`: `some_i32`, `none_i32`, `is_some_i32`, `is_none_i32`, `unwrap_some_i32`, `unwrap_or_i32` - `(option i64)`: `some_i64`, `none_i64`, `is_some_i64`, `is_none_i64`, `unwrap_some_i64`, `unwrap_or_i64` - `(option f64)`: `some_f64`, `none_f64`, `is_some_f64`, `is_none_f64`, `unwrap_some_f64`, `unwrap_or_f64` - `(option bool)`: `some_bool`, `none_bool`, `is_some_bool`, `is_none_bool`, `unwrap_some_bool`, `unwrap_or_bool` - `(option string)`: `some_string`, `none_string`, `is_some_string`, `is_none_string`, `unwrap_some_string`, `unwrap_or_string` All helpers remain ordinary Slovo source over the already promoted option forms, observers, extraction, `if`, parameters, and explicit signatures. The release also broadens the supported and formatter `option-result*` fixtures so raw option returns, immutable value flow, payload extraction, and source-level `match` now cover `(option f64)` and `(option bool)` as well. The matching explicit import fixture, `examples/projects/std-import-option/`, now deterministically exercises the `i32`, `i64`, `f64`, `bool`, and `string` helper families, with 16 passed tests in the explicit project fixture. The matching workspace fixture, `examples/workspaces/std-import-option/`, broadens the same staged helper surface through the existing explicit workspace source-search lane. exp-102 does not add compiler-known `std.option.*` runtime names, generic option helpers, option payload families beyond `i32`, `i64`, `f64`, `bool`, and `string`, option equality, option printing, nested/container option support, automatic or compiler-loaded std imports, stable ABI/layout claims, or beta maturity. ## exp-101 (released experimental alpha) Release label: `exp-101` Release name: Standard Vec String Option And Transform Helpers Alpha Release date: 2026-05-21 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_101_STANDARD_VEC_STRING_OPTION_AND_TRANSFORM_HELPERS_ALPHA.md`. exp-101 broadens `std/vec_string.slo` from the exp-99 baseline with one connected helper package: - option-query helpers: `index_option`, `first_option`, `last_option`, `index_of_option`, `last_index_of_option` - transform helpers: `concat`, `take`, `drop`, `reverse`, `subvec` The baseline direct wrappers, builder helpers, query helpers, and simple real-program helpers remain in place. The new helpers stay ordinary Slovo source over the existing `std.vec.string.*` facade operations, string equality, integer comparisons, and raw current `(option string)` / `(option i32)` forms. The lane stays recursive and immutable with no `var` or `set`. The matching explicit import fixture, `examples/projects/std-import-vec_string/`, now deterministically exercises the baseline, option-query, transform, subvec, and real-program helper groups, with 9 passed tests in the explicit project fixture. exp-101 does not add compiler-known `std.*` runtime names, generics, vec element families beyond `i32`, `i64`, and `string`, edit helpers, prefix/suffix helpers, nested vecs or vecs inside other containers, mutating/capacity APIs, stable ABI/layout claims, or beta maturity. ## exp-100 (released experimental alpha) Release label: `exp-100` Release name: Standard Option String Baseline Alpha Release date: 2026-05-21 Status: released experimental alpha source/core-language contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_100_STANDARD_OPTION_STRING_BASELINE_ALPHA.md`. exp-100 broadens the staged `std/option.slo` helper surface and the current core-language option slice from concrete `(option i32)` plus `(option i64)` to concrete `(option i32)`, `(option i64)`, and `(option string)`. The staged source helper surface is now: - `(option i32)`: `some_i32`, `none_i32`, `is_some_i32`, `is_none_i32`, `unwrap_some_i32`, `unwrap_or_i32` - `(option i64)`: `some_i64`, `none_i64`, `is_some_i64`, `is_none_i64`, `unwrap_some_i64`, `unwrap_or_i64` - `(option string)`: `some_string`, `none_string`, `is_some_string`, `is_none_string`, `unwrap_some_string`, `unwrap_or_string` All helpers remain ordinary Slovo source over the already promoted option forms, tag observers, extraction, `if`, parameters, and explicit signatures. The release also broadens the supported and formatter `option-result*` fixtures so raw option returns, immutable value flow, payload extraction, and source-level `match` now cover `(option string)` as well. The matching explicit import fixture, `examples/projects/std-import-option/`, now deterministically exercises the `i32`, `i64`, and `string` helper families, with 10 passed tests in the explicit project fixture. The matching workspace fixture, `examples/workspaces/std-import-option/`, broadens the same staged helper surface through the existing explicit workspace source-search lane. exp-100 does not add compiler-known `std.option.*` runtime names, generic option helpers, option payload families beyond `i32`, `i64`, and `string`, option equality, option printing, nested/container option support, automatic or compiler-loaded std imports, stable ABI/layout claims, or beta maturity. ## exp-99 (released experimental alpha) Release label: `exp-99` Release name: Standard Vec String Baseline Alpha Release date: 2026-05-21 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_99_STANDARD_VEC_STRING_BASELINE_ALPHA.md`. exp-99 adds `std/vec_string.slo` as the first usable source-authored `(vec string)` facade over the sibling concrete `std.vec.string` runtime family. Its public surface is: - direct wrappers: `empty`, `append`, `len`, and `at` - builder helpers: `singleton`, `append2`, `append3`, `pair`, and `triple` - query helpers: `is_empty`, `index_or`, `first_or`, and `last_or` - simple real-program helpers: `contains` and `count_of` The direct wrappers call only `std.vec.string.empty`, `std.vec.string.append`, `std.vec.string.len`, and `std.vec.string.index`. The remaining helpers are ordinary deterministic Slovo source helpers over that direct surface, string equality, integer comparison, and `i32` counting. `index_or` returns its fallback for negative and out-of-range positions, `first_or` delegates to `index_or values 0 fallback`, `last_or` provides a stable empty-vector fallback, `contains` returns `true` exactly when any element equals the target, and `count_of` returns `0` for empty vectors or absent targets while counting repeated matches exactly. The matching explicit import fixture, `examples/projects/std-import-vec_string/`, deterministically exercises the direct facade plus the builder, query, contains, and count_of helpers, with 6 passed tests in the explicit project fixture. The release also adds `examples/supported/vec-string.slo` with matching formatter coverage in `examples/formatter/vec-string.slo` for the raw `std.vec.string.*` runtime surface, vector equality, and append immutability. exp-99 does not add generics, vec element families beyond `i32`, `i64`, and `string`, option-query helpers, transform/range/edit helpers, nested vecs or vecs inside other containers, mutating/capacity APIs, stable ABI/layout claims, or beta maturity. ## exp-98 (released experimental alpha) Release label: `exp-98` Release name: Standard Vec I64 Edit Helpers Alpha Release date: 2026-05-21 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_98_STANDARD_VEC_I64_EDIT_HELPERS_ALPHA.md`. exp-98 extends `std/vec_i64.slo` with exactly six new public helpers over the existing concrete vec i64 runtime family: - `insert_at` - `insert_range` - `replace_at` - `replace_range` - `remove_at` - `remove_range` The helper surface stays concrete to `(vec i64)` and remains source-authored and compositional over the already released vec_i64 helper surface, especially `concat`, `take`, `drop`, and `append`. The full `vec_i64` source family stays recursive and immutable: there are no `var` or `set` locals in `std/vec_i64.slo`. `insert_at ((values (vec i64)) (position i32) (value i64)) -> (vec i64)` inserts before the current element at an in-range `position`, appends at `position == len(values)`, and returns `values` unchanged for negative or greater-than-length positions. `insert_range ((values (vec i64)) (position i32) (inserted (vec i64))) -> (vec i64)` follows the same position rules while preserving the order of both vectors. `replace_at` replaces one in-range element and returns `values` unchanged for negative or out-of-range positions. `replace_range ((values (vec i64)) (start i32) (end_exclusive i32) (replacement (vec i64))) -> (vec i64)` replaces the half-open range `[start, end_exclusive)`, returns `values` unchanged for negative, empty, or past-end starts, and replaces the tail when `end_exclusive` extends past the source length. `remove_at` removes one in-range element and otherwise returns `values` unchanged. `remove_range` removes the half-open range `[start, end_exclusive)`, returns `values` unchanged for negative, empty, or past-end starts, and removes the tail when `end_exclusive` extends past the source length. The matching explicit import fixture, `examples/projects/std-import-vec_i64/`, deterministically exercises the new edit helper package alongside the earlier builder, query, option-query, transform, subvec, and real-program groups, with 15 passed tests in the explicit project fixture. exp-98 does not add generics, new compiler-known `std.*` runtime names, mutation/capacity APIs, iterators, sort/map/filter, or beta maturity. ## exp-97 (released experimental alpha) Release label: `exp-97` Release name: Standard Vec I64 Transform Helpers Alpha Release date: 2026-05-21 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_97_STANDARD_VEC_I64_TRANSFORM_HELPERS_ALPHA.md`. exp-97 extends `std/vec_i64.slo` with exactly five new public helpers over the existing concrete vec i64 runtime family: - `concat` - `take` - `drop` - `reverse` - `subvec` The helper surface stays concrete to `(vec i64)` and remains source-authored over the existing `append`, `len`, `at`, and `empty` facade operations only. The full `vec_i64` source family stays recursive and immutable: there are no `var` or `set` locals in `std/vec_i64.slo`. `concat ((left (vec i64)) (right (vec i64))) -> (vec i64)` preserves the order of both inputs and returns a copied left-then-right result. `take` treats negative counts as zero and returns the original vector when the requested count reaches or exceeds the current length. `drop` treats negative counts as zero and returns an empty vector when the requested count reaches or exceeds the current length. `reverse` returns a copied vector in reverse order. `subvec ((values (vec i64)) (start i32) (end_exclusive i32)) -> (vec i64)` returns a copied half-open range, returns `(empty)` for negative or empty ranges, and returns the remaining tail when `end_exclusive` extends past the source length. The matching explicit import fixture, `examples/projects/std-import-vec_i64/`, deterministically exercises the new transform helper package alongside the earlier direct-wrapper, builder, query, option-query, contains, and sum groups, with 9 passed tests in the explicit project fixture. exp-97 does not add insert/replace/remove helpers for `(vec i64)`, generics, new compiler-known `std.*` runtime names, mutation/capacity APIs, iterators, sort/map/filter, or beta maturity. ## exp-96 (released experimental alpha) Release label: `exp-96` Release name: Standard Vec I64 Option Query Helpers Alpha Release date: 2026-05-20 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_96_STANDARD_VEC_I64_OPTION_QUERY_HELPERS_ALPHA.md`. exp-96 extends `std/vec_i64.slo` with exactly five new public helpers over the existing concrete vec i64 runtime family: - `index_option` - `first_option` - `last_option` - `index_of_option` - `last_index_of_option` The option-returning helper surface stays concrete to `(option i64)` and `(option i32)`. The module stays self-contained and explicit by constructing raw current `some` and `none` option values directly instead of importing `std.option`. `index_option ((values (vec i64)) (position i32)) -> (option i64)` returns `(none i64)` for negative and out-of-range positions and `(some i64 ...)` for in-range positions. `first_option` delegates to `index_option values 0`. `last_option` returns `(none i64)` for empty vectors and the final element as `(some i64 ...)` otherwise. `index_of_option` returns the first matching position as `(some i32 ...)` and `(none i32)` when the target is absent. `last_index_of_option` returns the last matching position as `(some i32 ...)` and `(none i32)` when the target is absent. The full `vec_i64` source family now stays recursive and immutable: there are no `var` or `set` locals in `std/vec_i64.slo`. The matching explicit import fixture, `examples/projects/std-import-vec_i64/`, deterministically exercises the new option-query helper group alongside the earlier direct-wrapper, builder, query, contains, and sum groups, with 7 passed tests in the explicit project fixture. exp-96 does not add transform/range/edit helpers for `(vec i64)`, generics, new compiler-known `std.*` runtime names, mutation/capacity APIs, iterators, sort/map/filter, or beta maturity. ## exp-95 (released experimental alpha) Release label: `exp-95` Release name: Standard Option I64 Baseline Alpha Release date: 2026-05-20 Status: released experimental alpha source/core-language contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_95_STANDARD_OPTION_I64_BASELINE_ALPHA.md`. exp-95 broadens the conservative option slice from only `(option i32)` to concrete `(option i32)` plus `(option i64)`. On the staged standard-library side, `std/option.slo` now includes: - constructors: `some_i32`, `none_i32`, `some_i64`, `none_i64` - observers: `is_some_i32`, `is_none_i32`, `is_some_i64`, `is_none_i64` - extract/fallback helpers: `unwrap_some_i32`, `unwrap_or_i32`, `unwrap_some_i64`, and `unwrap_or_i64` On the conservative core-language side, exp-95 broadens immutable option value flow, direct constructor returns, tag observation, trap-based payload extraction, and source-level `match` to `(option i64)`. The matching Slovo fixtures now exercise raw `(option i64)` returns, value flow, payload access, and `match`, and the explicit `std.option` import project now exercises both the `i32` and `i64` helper families. exp-95 does not add compiler-known `std.*` runtime names, automatic `std` imports/search, generic option helpers, option payload families beyond `i32` and `i64`, nested/container option support, option equality or printing, stable ABI/layout claims, manifest schema changes, or beta maturity. ## exp-94 (released experimental alpha) Release label: `exp-94` Release name: Standard Vec I64 Baseline Alpha Release date: 2026-05-20 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_94_STANDARD_VEC_I64_BASELINE_ALPHA.md`. exp-94 adds `std/vec_i64.slo` as the first usable source-authored `(vec i64)` facade over the sibling concrete vec runtime family. Its public surface is: - direct wrappers: `empty`, `append`, `len`, and `at` - builder helpers: `singleton`, `append2`, `append3`, `pair`, and `triple` - query helpers: `is_empty`, `index_or`, `first_or`, and `last_or` - simple real-program helpers: `contains` and `sum` The direct wrappers call only `std.vec.i64.empty`, `std.vec.i64.append`, `std.vec.i64.len`, and `std.vec.i64.index`. The remaining helpers are ordinary deterministic Slovo source helpers over that direct surface, current control flow, integer comparison, equality, and `i64` addition. `index_or` returns its fallback for negative and out-of-range positions, `first_or` and `last_or` provide stable empty-vector fallbacks, `contains` returns `true` exactly when any element equals the target, and `sum` returns `0i64` for empty vectors. The matching explicit import fixture, `examples/projects/std-import-vec_i64/`, deterministically exercises the direct wrappers plus the builder, query, contains, and sum helpers, with 6 passed tests in the explicit project fixture. The release also adds `examples/supported/vec-i64.slo` with matching formatter coverage in `examples/formatter/vec-i64.slo` for the raw `std.vec.i64.*` runtime surface, vector equality, and append immutability. exp-94 does not add generic vectors, `vec f64`, `vec string`, option/result payload widening, automatic standard-library imports, compiler-loaded standard-library source, new compiler-known `std.*` runtime names on the Slovo side, transform/range-edit helper families for `(vec i64)`, mutating vec APIs, capacity or reserve management, sorting, mapping, filtering, iterators, stable ABI/layout/ownership, optimizer guarantees, or beta maturity. ## exp-93 (released experimental alpha) Release label: `exp-93` Release name: Standard Vec I32 Count-Of Helper Alpha Release date: 2026-05-20 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_93_STANDARD_VEC_I32_COUNT_OF_HELPER_ALPHA.md`. exp-93 extends `std/vec_i32.slo` with exactly one new public helper over the already promoted concrete vec runtime family: - `count_of` This is an ordinary Slovo source function over the existing `len`, `at`, equality, and `while` surface; it adds no new runtime calls, compiler semantic changes, private recursive helper, or compiler-known `std.*` names. `count_of ((values (vec i32)) (target i32)) -> i32` returns the number of elements of `values` equal to `target`. It returns `0` for an empty vector and when `target` is absent, counts repeated matches exactly, and leaves the source vector unchanged. The matching explicit import fixture, `examples/projects/std-import-vec_i32/`, deterministically exercises empty, repeated-match, single-match, no-match, and unchanged-source cases alongside the earlier vec helper groups, with 22 passed tests in the explicit project fixture. exp-93 does not add generic collections, vector payload families beyond `(vec i32)`, slice/view types, automatic standard-library imports, compiler-loaded standard-library source, new compiler-known `std.*` runtime names, mutable vec locals, broader vec aggregation or filter families beyond the current concrete helper surface, mutating vec APIs, capacity or reserve management, sorting, mapping, filtering, iterators, stable ABI/layout/ownership, optimizer guarantees, or beta maturity. ## exp-92 (released experimental alpha) Release label: `exp-92` Release name: Standard Vec I32 Without-Prefix Helper Alpha Release date: 2026-05-20 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_92_STANDARD_VEC_I32_WITHOUT_PREFIX_HELPER_ALPHA.md`. exp-92 extends `std/vec_i32.slo` with exactly one new public helper over the already promoted concrete vec runtime family: - `without_prefix` This is an ordinary compositional Slovo source function over the existing `starts_with`, `drop`, and `len` helpers; it adds no new runtime calls, compiler semantic changes, private recursive helper, or compiler-known `std.*` names. `without_prefix ((values (vec i32)) (prefix (vec i32))) -> (vec i32)` removes a matching leading prefix from `values`. It returns `values` unchanged for an empty prefix, a longer prefix, or a mismatched prefix, returns `(empty)` when `values` exactly equals `prefix`, and leaves both source vectors unchanged. The matching explicit import fixture, `examples/projects/std-import-vec_i32/`, deterministically exercises empty, exact, shorter matching, longer non-matching, mismatched, and unchanged-source prefix cases alongside the earlier vec helper groups, with 21 passed tests in the explicit project fixture. exp-92 does not add generic collections, vector payload families beyond `(vec i32)`, slice/view types, automatic standard-library imports, compiler-loaded standard-library source, new compiler-known `std.*` runtime names, mutable vec locals, broader prefix/suffix helper families beyond `starts_with`, `without_prefix`, `ends_with`, and `without_suffix`, broader copied subvector/range-edit helper families beyond `insert_range`, `replace_range`, `remove_range`, `subvec`, `without_prefix`, and `without_suffix`, mutating vec APIs, capacity or reserve management, sorting, mapping, filtering, iterators, stable ABI/layout/ownership, optimizer guarantees, or beta maturity. ## exp-91 (released experimental alpha) Release label: `exp-91` Release name: Standard Vec I32 Without-Suffix Helper Alpha Release date: 2026-05-20 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_91_STANDARD_VEC_I32_WITHOUT_SUFFIX_HELPER_ALPHA.md`. exp-91 extends `std/vec_i32.slo` with exactly one new public helper over the already promoted concrete vec runtime family: - `without_suffix` This is an ordinary compositional Slovo source function over the existing `ends_with`, `take`, and `len` helpers; it adds no new runtime calls, compiler semantic changes, private recursive helper, or compiler-known `std.*` names. `without_suffix ((values (vec i32)) (suffix (vec i32))) -> (vec i32)` removes a matching trailing suffix from `values`. It returns `values` unchanged for an empty suffix, a longer suffix, or a mismatched suffix, returns `(empty)` when `values` exactly equals `suffix`, and leaves both source vectors unchanged. The matching explicit import fixture, `examples/projects/std-import-vec_i32/`, deterministically exercises empty, exact, shorter matching, longer non-matching, mismatched, and unchanged-source suffix cases alongside the earlier vec helper groups, with 20 passed tests in the explicit project fixture. exp-91 does not add generic collections, vector payload families beyond `(vec i32)`, slice/view types, automatic standard-library imports, compiler-loaded standard-library source, new compiler-known `std.*` runtime names, mutable vec locals, broader prefix/suffix helper families beyond `starts_with`, `ends_with`, and `without_suffix`, broader copied subvector/range-edit helper families beyond `insert_range`, `replace_range`, `remove_range`, `subvec`, and `without_suffix`, mutating vec APIs, capacity or reserve management, sorting, mapping, filtering, iterators, stable ABI/layout/ownership, optimizer guarantees, or beta maturity. ## exp-90 (released experimental alpha) Release label: `exp-90` Release name: Standard Vec I32 Ends-With Helper Alpha Release date: 2026-05-20 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_90_STANDARD_VEC_I32_ENDS_WITH_HELPER_ALPHA.md`. exp-90 extends `std/vec_i32.slo` with exactly one new public helper over the already promoted concrete vec runtime family: - `ends_with` This is an ordinary compositional Slovo source function over the existing `drop`, `len`, and vec equality helpers; it adds no new runtime calls, compiler semantic changes, private recursive helper, or compiler-known `std.*` names. `ends_with ((values (vec i32)) (suffix (vec i32))) -> bool` returns `true` exactly when `values` ends with all elements of `suffix` in order. It returns `true` for an empty suffix, `false` when `len(suffix) > len(values)`, `true` for equal vectors and shorter matching suffixes, and `false` for mismatched suffixes. The helper leaves both source vectors unchanged. The matching explicit import fixture, `examples/projects/std-import-vec_i32/`, deterministically exercises empty, equal, shorter matching, longer non-matching, mismatched, and unchanged-source suffix cases alongside the earlier vec helper groups, with 19 passed tests in the explicit project fixture. exp-90 does not add generic collections, vector payload families beyond `(vec i32)`, slice/view types, automatic standard-library imports, compiler-loaded standard-library source, new compiler-known `std.*` runtime names, mutable vec locals, broader prefix/suffix query helpers beyond `starts_with` and `ends_with`, broader copied subvector/range-edit helper families beyond `insert_range`, `replace_range`, `remove_range`, and `subvec`, mutating vec APIs, capacity or reserve management, sorting, mapping, filtering, iterators, stable ABI/layout/ownership, optimizer guarantees, or beta maturity. ## exp-89 (released experimental alpha) Release label: `exp-89` Release name: Standard Vec I32 Starts-With Helper Alpha Release date: 2026-05-20 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_89_STANDARD_VEC_I32_STARTS_WITH_HELPER_ALPHA.md`. exp-89 extends `std/vec_i32.slo` with exactly one new public helper over the already promoted concrete vec runtime family: - `starts_with` This is an ordinary compositional Slovo source function over the existing `take`, `len`, and vec equality helpers; it adds no new runtime calls, compiler semantic changes, private recursive helper, or compiler-known `std.*` names. `starts_with ((values (vec i32)) (prefix (vec i32))) -> bool` returns `true` exactly when `values` begins with all elements of `prefix` in order. It returns `true` for an empty prefix, `false` when `len(prefix) > len(values)`, `true` for equal vectors and shorter matching prefixes, and `false` for mismatched prefixes. The helper leaves both source vectors unchanged. The matching explicit import fixture, `examples/projects/std-import-vec_i32/`, deterministically exercises empty, equal, shorter matching, longer non-matching, mismatched, and unchanged-source cases alongside the earlier vec helper groups, with 18 passed tests in the explicit project fixture. exp-89 does not add generic collections, vector payload families beyond `(vec i32)`, slice/view types, automatic standard-library imports, compiler-loaded standard-library source, new compiler-known `std.*` runtime names, mutable vec locals, broader prefix/suffix query helpers beyond `starts_with`, broader copied subvector/range-edit helper families beyond `insert_range`, `replace_range`, `remove_range`, and `subvec`, mutating vec APIs, capacity or reserve management, sorting, mapping, filtering, iterators, stable ABI/layout/ownership, optimizer guarantees, or beta maturity. ## exp-88 (released experimental alpha) Release label: `exp-88` Release name: Standard Vec I32 Replace Range Helper Alpha Release date: 2026-05-20 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_88_STANDARD_VEC_I32_REPLACE_RANGE_HELPER_ALPHA.md`. exp-88 extends `std/vec_i32.slo` with exactly one new public helper over the already promoted concrete vec runtime family: - `replace_range` This is an ordinary compositional Slovo source function over the existing `take`, `drop`, and `concat` vec helpers; it adds no new runtime calls, compiler semantic changes, private recursive helper, or compiler-known `std.*` names. `replace_range ((values (vec i32)) (start i32) (end_exclusive i32) (replacement (vec i32))) -> (vec i32)` replaces the half-open range `[start, end_exclusive)` with all of `replacement` when the start is valid. If `start < 0`, `end_exclusive <= start`, or `start >= len(values)`, it returns `values` unchanged. If `end_exclusive >= len(values)`, it replaces the tail from `start`. The helper preserves prefix order, then replacement order, then surviving suffix order, and does not mutate either source vector. The matching explicit import fixture, `examples/projects/std-import-vec_i32/`, deterministically exercises middle replacement, tail replacement, unchanged invalid-range, unchanged-source-vector, unchanged-replacement-vector, and preserved-order cases alongside the earlier vec helper groups, with 17 passed tests in the explicit project fixture. exp-88 does not add generic collections, vector payload families beyond `(vec i32)`, slice/view types, automatic standard-library imports, compiler-loaded standard-library source, new compiler-known `std.*` runtime names, mutable vec locals, broader copied subvector/range-edit helper families beyond `insert_range`, `replace_range`, `remove_range`, and `subvec`, public insert/remove/edit families beyond `insert_range`, `replace_range`, `remove_range`, `subvec`, `insert_at`, `replace_at`, and `remove_at`, mutating vec APIs, capacity or reserve management, sorting, mapping, filtering, iterators, stable ABI/layout/ownership, optimizer guarantees, or beta maturity. ## exp-87 (released experimental alpha) Release label: `exp-87` Release name: Standard Vec I32 Insert Range Helper Alpha Release date: 2026-05-20 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_87_STANDARD_VEC_I32_INSERT_RANGE_HELPER_ALPHA.md`. exp-87 extends `std/vec_i32.slo` with exactly one new public helper over the already promoted concrete vec runtime family: - `insert_range` This is an ordinary compositional Slovo source function over the existing `take`, `drop`, and `concat` vec helpers; it adds no new runtime calls, compiler semantic changes, private recursive helper, or compiler-known `std.*` names. `insert_range ((values (vec i32)) (position i32) (inserted (vec i32))) -> (vec i32)` returns a new vector when `position` is valid: if `0 <= position < len(values)`, it inserts all of `inserted` before the current element at `position`, and if `position == len(values)`, it appends `inserted` at the end. The result length is then `len(values) + len(inserted)`. If `position < 0` or `position > len(values)`, it returns `values` unchanged. The helper preserves the order of both vectors and does not mutate either source vector. The matching explicit import fixture, `examples/projects/std-import-vec_i32/`, deterministically exercises middle insertion, append-at-end insertion, negative-position, out-of-range-position, and unchanged-source-vector cases alongside the earlier vec helper groups. exp-87 does not add generic collections, vector payload families beyond `(vec i32)`, slice/view types, automatic standard-library imports, compiler-loaded standard-library source, new compiler-known `std.*` runtime names, mutable vec locals, broader copied subvector/range-edit helper families beyond `insert_range`, `remove_range`, and `subvec`, public insert/remove/edit families beyond `insert_range`, `remove_range`, `subvec`, `insert_at`, `replace_at`, and `remove_at`, mutating vec APIs, capacity or reserve management, sorting, mapping, filtering, iterators, stable ABI/layout/ownership, optimizer guarantees, or beta maturity. ## exp-86 (released experimental alpha) Release label: `exp-86` Release name: Standard Vec I32 Remove Range Helper Alpha Release date: 2026-05-20 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_86_STANDARD_VEC_I32_REMOVE_RANGE_HELPER_ALPHA.md`. exp-86 extends `std/vec_i32.slo` with exactly one new public helper over the already promoted concrete vec runtime family: - `remove_range` This is an ordinary compositional Slovo source function over the existing `take`, `drop`, and `concat` vec helpers; it adds no new runtime calls, compiler semantic changes, private recursive helper, or compiler-known `std.*` names. `remove_range ((values (vec i32)) (start i32) (end_exclusive i32)) -> (vec i32)` removes the half-open range `[start, end_exclusive)` from `values` while preserving the order of the remaining elements. If `start < 0`, `end_exclusive <= start`, or `start >= len(values)`, it returns `values` unchanged. If `end_exclusive >= len(values)`, it removes the tail from `start`. The helper leaves the source vector unchanged. The matching explicit import fixture, `examples/projects/std-import-vec_i32/`, deterministically exercises middle-range removal, tail removal, `end_exclusive <= start`, out-of-range-start, negative-start, and unchanged-source cases alongside the earlier vec helper groups. exp-86 does not add generic collections, vector payload families beyond `(vec i32)`, slice/view types, automatic standard-library imports, compiler-loaded standard-library source, new compiler-known `std.*` runtime names, mutable vec locals, broader subvector/range-removal helper families beyond `remove_range` and `subvec`, public insert/remove/edit families beyond `remove_range`, `subvec`, `insert_at`, `replace_at`, and `remove_at`, mutating vec APIs, capacity or reserve management, sorting, mapping, filtering, iterators, stable ABI/layout/ownership, optimizer guarantees, or beta maturity. ## exp-85 (released experimental alpha) Release label: `exp-85` Release name: Standard Vec I32 Subvec Helper Alpha Release date: 2026-05-20 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_85_STANDARD_VEC_I32_SUBVEC_HELPER_ALPHA.md`. exp-85 extends `std/vec_i32.slo` with exactly one new public helper over the already promoted concrete vec runtime family: - `subvec` This is an ordinary compositional Slovo source function over the existing `take` and `drop` vec helpers; it adds no new runtime calls, compiler semantic changes, private recursive helper, or compiler-known `std.*` names. `subvec ((values (vec i32)) (start i32) (end_exclusive i32)) -> (vec i32)` returns a copied contiguous subvector `[start, end_exclusive)`. If `start < 0`, `end_exclusive <= start`, or `start >= len(values)`, it returns `(empty)`. If `end_exclusive > len(values)`, it returns the remaining tail from `start`. The helper preserves source order, leaves the source vector unchanged, and remains an ordinary copied vec helper rather than a slice/view type. The matching explicit import fixture, `examples/projects/std-import-vec_i32/`, deterministically exercises middle-range, tail-truncation, empty-range, out-of-range, negative-start, and unchanged-source cases alongside the earlier vec helper groups. exp-85 does not add generic collections, vector payload families beyond `(vec i32)`, slice/view types, automatic standard-library imports, compiler-loaded standard-library source, new compiler-known `std.*` runtime names, mutable vec locals, broader copied subvector/window helpers beyond `subvec`, public insert/remove/edit families beyond `subvec`, `insert_at`, `replace_at`, and `remove_at`, mutating vec APIs, capacity or reserve management, sorting, mapping, filtering, iterators, stable ABI/layout/ownership, optimizer guarantees, or beta maturity. ## exp-84 (released experimental alpha) Release label: `exp-84` Release name: Standard Vec I32 Insert Helper Alpha Release date: 2026-05-20 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_84_STANDARD_VEC_I32_INSERT_HELPER_ALPHA.md`. exp-84 extends `std/vec_i32.slo` with exactly one new public helper over the already promoted concrete vec runtime family: - `insert_at` This is an ordinary compositional Slovo source function over the existing `append`, `take`, `drop`, and `concat` vec helpers; it adds no new runtime calls, compiler semantic changes, private recursive helper, or compiler-known `std.*` names. `insert_at ((values (vec i32)) (position i32) (value i32)) -> (vec i32)` returns a new vector when `position` is valid: if `0 <= position < len(values)`, it inserts `value` before the current element at `position`, and if `position == len(values)`, it appends `value` at the end. The result length is then `len(values) + 1`. If `position < 0` or `position > len(values)`, it returns `values` unchanged. The helper does not mutate the source vector. The matching explicit import fixture, `examples/projects/std-import-vec_i32/`, deterministically exercises middle-insert, append-at-end, negative, and out-of-range insertion cases alongside the earlier vec helper groups. exp-84 does not add generic collections, vector payload families beyond `(vec i32)`, slice types, automatic standard-library imports, compiler-loaded standard-library source, new compiler-known `std.*` runtime names, mutable vec locals, public insert/remove/edit families beyond `insert_at`, `replace_at`, and `remove_at`, mutating vec APIs, capacity or reserve management, sorting, mapping, filtering, iterators, stable ABI/layout/ownership, optimizer guarantees, or beta maturity. ## exp-83 (released experimental alpha) Release label: `exp-83` Release name: Standard Vec I32 Remove Helper Alpha Release date: 2026-05-20 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_83_STANDARD_VEC_I32_REMOVE_HELPER_ALPHA.md`. exp-83 extends `std/vec_i32.slo` with exactly one new public helper over the already promoted concrete vec runtime family: - `remove_at` This is an ordinary compositional Slovo source function over the existing `take`, `drop`, and `concat` vec helpers; it adds no new runtime calls, compiler semantic changes, private recursive helper, or compiler-known `std.*` names. `remove_at ((values (vec i32)) (position i32)) -> (vec i32)` returns a new vector with the element at `position` removed when `0 <= position < len(values)`, preserving the order of the remaining elements. The result length is then `len(values) - 1`. If `position < 0` or `position >= len(values)`, it returns `values` unchanged. The helper does not mutate the source vector. The matching explicit import fixture, `examples/projects/std-import-vec_i32/`, deterministically exercises in-range, negative, and out-of-range removal cases alongside the earlier vec helper groups. exp-83 does not add generic collections, vector payload families beyond `(vec i32)`, slice types, automatic standard-library imports, compiler-loaded standard-library source, new compiler-known `std.*` runtime names, mutable vec locals, public insert/remove/edit families beyond `replace_at` and `remove_at`, mutating vec APIs, capacity or reserve management, sorting, mapping, filtering, iterators, stable ABI/layout/ownership, optimizer guarantees, or beta maturity. ## exp-82 (released experimental alpha) Release label: `exp-82` Release name: Standard Vec I32 Replace Helper Alpha Release date: 2026-05-20 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_82_STANDARD_VEC_I32_REPLACE_HELPER_ALPHA.md`. exp-82 extends `std/vec_i32.slo` with exactly one new public helper over the already promoted concrete vec runtime family: - `replace_at` This is an ordinary compositional Slovo source function over the existing `append`, `take`, `drop`, and `concat` vec helpers; it adds no new runtime calls, compiler semantic changes, or compiler-known `std.*` names. `replace_at ((values (vec i32)) (position i32) (replacement i32)) -> (vec i32)` returns a new vector with the same length and order as `values` except that the in-range `position` slot becomes `replacement`. If `position < 0` or `position >= len(values)`, it returns `values` unchanged. The helper does not mutate the source vector. The matching explicit import fixture, `examples/projects/std-import-vec_i32/`, deterministically exercises in-range, negative, and out-of-range replacement cases alongside the earlier vec helper groups. exp-82 does not add generic collections, vector payload families beyond `(vec i32)`, slice types, automatic standard-library imports, compiler-loaded standard-library source, new compiler-known `std.*` runtime names, mutable vec locals, public insert/remove/edit families beyond `replace_at`, mutating vec APIs, capacity or reserve management, sorting, mapping, filtering, iterators, stable ABI/layout/ownership, optimizer guarantees, or beta maturity. ## exp-81 (released experimental alpha) Release label: `exp-81` Release name: Standard Vec I32 Range Helper Alpha Release date: 2026-05-20 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_81_STANDARD_VEC_I32_RANGE_HELPER_ALPHA.md`. exp-81 extends `std/vec_i32.slo` with exactly one new public helper over the already promoted concrete vec runtime family: - `range` This is an ordinary Slovo source function over the existing `append` and `empty` vec facade operations, with private recursive generation only. `range ((start i32) (end_exclusive i32)) -> (vec i32)` produces an ascending half-open sequence from `start` up to but excluding `end_exclusive`. Negative bounds are allowed, and it returns an empty vector when `end_exclusive <= start`. `range_from_zero` remains public and may delegate to `range 0 count`. The matching explicit import fixture, `examples/projects/std-import-vec_i32/`, deterministically exercises negative, empty, and positive ascending range cases alongside the earlier vec helper groups. exp-81 does not add generic collections, vector payload families beyond `(vec i32)`, slice types, automatic standard-library imports, compiler-loaded standard-library source, new compiler-known `std.*` runtime names, mutable vec locals, descending or stepped range variants, inclusive range variants, edit helpers, mutating vec APIs, capacity or reserve management, sorting, mapping, filtering, iterators, stable ABI/layout/ownership, optimizer guarantees, or beta maturity. ## exp-80 (released experimental alpha) Release label: `exp-80` Release name: Standard Vec I32 Generated Constructor Helpers Alpha Release date: 2026-05-20 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_80_STANDARD_VEC_I32_GENERATED_CONSTRUCTOR_HELPERS_ALPHA.md`. exp-80 extends `std/vec_i32.slo` with narrow generated constructor helpers over the already promoted concrete vec runtime family: - `repeat` - `range_from_zero` These are ordinary Slovo source functions over the existing `append` and `empty` vec facade operations. `repeat` returns an empty vector when `count <= 0`. `range_from_zero` produces `0`, `1`, and so on up to but excluding `count`, and returns an empty vector when `count <= 0`. The matching explicit import fixture, `examples/projects/std-import-vec_i32/`, now deterministically exercises this constructor helper group alongside the earlier direct, builder, fallback query, option-query, transform, and real-program vec helpers. exp-80 does not add generic collections, vector payload families beyond `(vec i32)`, slice types, automatic standard-library imports, compiler-loaded standard-library source, new compiler-known `std.*` runtime names, mutable vec locals, mutating vec APIs, capacity or reserve management, public `range`, descending or stepped range variants, inclusive range variants, edit helpers, sorting, mapping, filtering, iterators, stable ABI/layout/ownership, optimizer guarantees, or beta maturity. ## exp-79 (released experimental alpha) Release label: `exp-79` Release name: Standard Vec I32 Transform Helpers Alpha Release date: 2026-05-20 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_79_STANDARD_VEC_I32_TRANSFORM_HELPERS_ALPHA.md`. exp-79 extends `std/vec_i32.slo` with narrow transform helpers over the already promoted concrete vec runtime family: - `concat` - `take` - `drop` - `reverse` These are ordinary Slovo source functions over the existing `append`, `len`, `at`, and `empty` vec facade operations. `concat`, `take`, `drop`, and `reverse` are expressed with private recursive helpers instead of mutable vec locals. Negative counts behave as zero; `take` returns the original vector when the requested count reaches or exceeds the current length, and `drop` returns an empty vector in that same case. The matching explicit import fixture, `examples/projects/std-import-vec_i32/`, now deterministically exercises this transform helper group alongside the earlier direct, builder, fallback query, option-query, and real-program vec helpers. exp-79 does not add generic collections, vector payload families beyond `(vec i32)`, slice types, automatic standard-library imports, compiler-loaded standard-library source, new compiler-known `std.*` runtime names, mutable vec locals, mutating vec APIs, capacity or reserve management, sorting, mapping, filtering, iterators, stable ABI/layout/ownership, optimizer guarantees, or beta maturity. ## exp-78 (released experimental alpha) Release label: `exp-78` Release name: Standard CLI Local Source Facade Alpha Release date: 2026-05-20 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_78_STANDARD_CLI_LOCAL_SOURCE_FACADE_ALPHA.md`. exp-78 records the staged `std/cli.slo` facade as the Slovo-side contract for the sibling Glagol local-source gate without widening the `std.cli` helper surface. `std/cli.slo` itself remains unchanged for this release, and the released helper list stays: - `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 facade remains ordinary Slovo source over existing `std.process` and `std.string` surface only, with no additional standard-source dependencies. The existing explicit import fixture, `examples/projects/std-import-cli/`, remains valid, and the paired Glagol local-source gate is expected to mirror the same composition pattern. exp-78 does not add new `std.cli` helpers, automatic standard-library imports, compiler-loaded standard-library source, a `std.slo` aggregator, package std dependency syntax, new compiler-known `std.*` runtime names, process spawning, exit/status control, current-directory APIs, signal handling, shell parsing, option or flag parsing, subcommands, environment-backed configuration, richer CLI framework APIs, stable ABI/layout/ownership, optimizer guarantees, or beta maturity. ## exp-77 (released experimental alpha) Release label: `exp-77` Release name: Standard Vec I32 Option Query Helpers Alpha Release date: 2026-05-20 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_77_STANDARD_VEC_I32_OPTION_QUERY_HELPERS_ALPHA.md`. exp-77 extends `std/vec_i32.slo` with concrete option-returning query helpers over the already promoted concrete vec runtime family: - `index_option` - `first_option` - `last_option` - `index_of_option` - `last_index_of_option` These are ordinary Slovo source functions over the existing `len`, `at`, and `while` vec facade operations plus `std.option.some_i32` and `std.option.none_i32`. The matching explicit import fixture, `examples/projects/std-import-vec_i32/`, now deterministically exercises this option-query helper group alongside the earlier direct, builder, fallback query, and real-program vec helpers. exp-77 does not add generic collections, vector payload families beyond `(vec i32)`, option payload families beyond `(option i32)`, automatic standard-library imports, compiler-loaded standard-library source, new compiler-known `std.*` runtime names, mutating vec APIs, capacity or reserve management, sorting, mapping, filtering, iterators, stable ABI/layout/ownership, optimizer guarantees, or beta maturity. ## exp-76 (released experimental alpha) Release label: `exp-76` Release name: Standard Vec I32 Source Helpers Alpha Release date: 2026-05-20 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_76_STANDARD_VEC_I32_SOURCE_HELPERS_ALPHA.md`. exp-76 extends `std/vec_i32.slo` with a concrete `(vec i32)` source-authored collection facade over the already promoted `std.vec.i32` runtime family: - direct wrappers: - `empty` - `append` - `len` - `at` - builder helpers: - `singleton` - `append2` - `append3` - `pair` - `triple` - query helpers: - `is_empty` - `index_or` - `first_or` - `last_or` - real-program helpers: - `contains` - `sum` These are ordinary Slovo source functions over the existing vector runtime calls plus simple source `while` loops. The matching explicit import fixture, `examples/projects/std-import-vec_i32/`, now exercises the direct facade and the staged helper groups through explicit `std.vec_i32` imports. exp-76 does not add generic vectors, vector payload families beyond `(vec i32)`, automatic standard-library imports, compiler-loaded standard-library source, capacity or reserve management, push/pop helpers, sorting, mapping, filtering, iterators, new compiler-known `std.*` runtime names, stable ABI/layout/ownership, optimizer guarantees, or beta maturity. ## exp-75 (released experimental alpha) Release label: `exp-75` Release name: Standard Option Constructors Alpha Release date: 2026-05-20 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_75_STANDARD_OPTION_CONSTRUCTORS_ALPHA.md`. exp-75 extends `std/option.slo` with concrete source constructors for the currently promoted `(option i32)` family: - `some_i32` - `none_i32` These are ordinary Slovo source functions over the existing `some` and `none` forms, fixed to the current released `(option i32)` family. The matching explicit import fixture, `examples/projects/std-import-option/`, now uses those constructors instead of repeating raw typed `some` and `none` forms. exp-75 does not add generic option helpers, new option payload families, automatic standard-library imports, compiler-loaded standard-library source, new compiler-known `std.*` runtime names, stable ABI/layout/ownership, optimizer guarantees, or beta maturity. ## exp-74 (released experimental alpha) Release label: `exp-74` Release name: Standard Result Constructor Helpers Alpha Release date: 2026-05-20 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_74_STANDARD_RESULT_CONSTRUCTOR_HELPERS_ALPHA.md`. exp-74 extends `std/result.slo` with concrete source constructors for the currently promoted result families: - `ok_i32` - `err_i32` - `ok_i64` - `err_i64` - `ok_string` - `err_string` - `ok_f64` - `err_f64` - `ok_bool` - `err_bool` These are ordinary Slovo source functions over the existing `ok` and `err` forms, fixed to the current released `(result i32)` families. The matching explicit import fixture, `examples/projects/std-import-result/`, now uses those constructors instead of repeating raw typed `ok` and `err` forms. exp-74 does not add generic result helpers, new result payload families, generic `map`/`and_then`, richer error ADTs, automatic standard-library imports, compiler-loaded standard-library source, new compiler-known `std.*` runtime names, stable ABI/layout/ownership, optimizer guarantees, or beta maturity. ## exp-73 (released experimental alpha) Release label: `exp-73` Release name: Standard Io Value Helpers Alpha Release date: 2026-05-20 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_73_STANDARD_IO_VALUE_HELPERS_ALPHA.md`. exp-73 extends `std/io.slo` with source-authored value-returning print helpers over the already promoted print runtime calls: - `print_i32_value` - `print_i64_value` - `print_f64_value` - `print_string_value` - `print_bool_value` These are ordinary Slovo source functions over `std.io.print_i32`, `std.io.print_i64`, `std.io.print_f64`, `std.io.print_string`, and `std.io.print_bool`, followed by returning the original value. The matching explicit import fixture, `examples/projects/std-import-io/`, now exercises both the earlier zero-returning wrappers and the new value-preserving cases. exp-73 does not add automatic standard-library imports, compiler-loaded standard-library source, stderr facade helpers, stdin facade helpers, line iteration, prompt APIs, terminal control, binary IO, streaming IO, async IO, new compiler-known `std.*` runtime names, stable ABI/layout/ownership, optimizer guarantees, or beta maturity. ## exp-72 (released experimental alpha) Release label: `exp-72` Release name: Standard Cli Custom Fallback Helpers Alpha Release date: 2026-05-20 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_72_STANDARD_CLI_CUSTOM_FALLBACK_HELPERS_ALPHA.md`. exp-72 extends `std/cli.slo` with source-authored typed argument custom-fallback helpers over the already promoted argument lookup and concrete parse result families: - `arg_i32_or` - `arg_i64_or` - `arg_f64_or` - `arg_bool_or` These are ordinary Slovo source functions over `arg_result`, `parse_i32_result`, `parse_i64_result`, `parse_f64_result`, and `parse_bool_result` plus source `match`. The matching explicit import fixture, `examples/projects/std-import-cli/`, now exercises both the earlier zero/false fallbacks and the new typed custom-fallback cases. exp-72 does not add automatic standard-library imports, compiler-loaded standard-library source, process spawning, exit/status control, current directory APIs, signal handling, shell parsing, subcommands, richer CLI framework APIs, generic configuration helpers, new compiler-known `std.*` runtime names, stable ABI/layout/ownership, optimizer guarantees, or beta maturity. ## exp-71 (released experimental alpha) ## exp-71 (released experimental alpha) Release label: `exp-71` Release name: Standard Process Custom Fallback Helpers Alpha Release date: 2026-05-20 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_71_STANDARD_PROCESS_CUSTOM_FALLBACK_HELPERS_ALPHA.md`. exp-71 extends `std/process.slo` with source-authored typed argument custom-fallback helpers over the already promoted argument lookup and concrete parse result families: - `arg_i32_or` - `arg_i64_or` - `arg_f64_or` - `arg_bool_or` These are ordinary Slovo source functions over `arg_result`, `parse_i32_result`, `parse_i64_result`, `parse_f64_result`, and `parse_bool_result` plus source `match`. The matching explicit import fixture, `examples/projects/std-import-process/`, now exercises both the earlier zero/false fallbacks and the new typed custom-fallback cases. exp-71 does not add automatic standard-library imports, compiler-loaded standard-library source, process spawning, exit/status control, current directory APIs, signal handling, shell parsing, subcommands, richer CLI framework APIs, generic configuration helpers, new compiler-known `std.*` runtime names, stable ABI/layout/ownership, optimizer guarantees, or beta maturity. ## exp-70 (released experimental alpha) ## exp-70 (released experimental alpha) Release label: `exp-70` Release name: Standard Fs Custom Fallback Helpers Alpha Release date: 2026-05-20 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_70_STANDARD_FS_CUSTOM_FALLBACK_HELPERS_ALPHA.md`. exp-70 extends `std/fs.slo` with source-authored typed read custom-fallback helpers over the already promoted text-read and concrete parse result families: - `read_i32_or` - `read_i64_or` - `read_f64_or` - `read_bool_or` These are ordinary Slovo source functions over `read_text_result`, `parse_i32_result`, `parse_i64_result`, `parse_f64_result`, and `parse_bool_result` plus source `match`. The matching explicit import fixture, `examples/projects/std-import-fs/`, now exercises both the earlier zero/false fallbacks and the new typed custom-fallback cases. exp-70 does not add automatic standard-library imports, compiler-loaded standard-library source, binary file APIs, directory traversal, streaming file IO, async file IO, typed file writes, rich host errors, new compiler-known `std.*` runtime names, stable ABI/layout/ownership, optimizer guarantees, or beta maturity. ## exp-69 (released experimental alpha) ## exp-69 (released experimental alpha) Release label: `exp-69` Release name: Standard Env Custom Fallback Helpers Alpha Release date: 2026-05-20 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_69_STANDARD_ENV_CUSTOM_FALLBACK_HELPERS_ALPHA.md`. exp-69 extends `std/env.slo` with source-authored typed parse custom-fallback helpers over the already promoted environment lookup and concrete parse result families: - `get_i32_or` - `get_i64_or` - `get_f64_or` - `get_bool_or` These are ordinary Slovo source functions over `get_result`, `parse_i32_result`, `parse_i64_result`, `parse_f64_result`, and `parse_bool_result` plus source `match`. The matching explicit import fixture, `examples/projects/std-import-env/`, now exercises both the earlier zero/false fallbacks and the new typed custom-fallback cases. exp-69 does not add automatic standard-library imports, compiler-loaded standard-library source, generic configuration helpers, environment mutation, environment enumeration, environment writes, rich host errors, new compiler-known `std.*` runtime names, stable ABI/layout/ownership, optimizer guarantees, or beta maturity. ## exp-68 (released experimental alpha) Release label: `exp-68` Release name: Standard String Custom Fallback Helpers Alpha Release date: 2026-05-20 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_68_STANDARD_STRING_CUSTOM_FALLBACK_HELPERS_ALPHA.md`. exp-68 extends `std/string.slo` with source-authored typed parse custom-fallback helpers over the already promoted concrete parse result families: - `parse_i32_or` - `parse_i64_or` - `parse_f64_or` - `parse_bool_or` These are ordinary Slovo source functions over `parse_i32_result`, `parse_i64_result`, `parse_f64_result`, and `parse_bool_result` plus source `match`. The matching explicit import fixture, `examples/projects/std-import-string/`, now exercises both the earlier zero/false fallbacks and the new typed custom-fallback cases. exp-68 does not add automatic standard-library imports, compiler-loaded standard-library source, generic parse helpers, whitespace trimming, case-insensitive bool parsing, rich parse errors, new compiler-known `std.*` runtime names, stable ABI/layout/ownership, optimizer guarantees, or beta maturity. ## exp-67 (released experimental alpha) Release label: `exp-67` Release name: Standard Process Typed Helpers Alpha Release date: 2026-05-20 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_67_STANDARD_PROCESS_TYPED_HELPERS_ALPHA.md`. exp-67 extends `std/process.slo` with source-authored typed argument result/fallback helpers over process arguments plus the already promoted concrete parse result families: - `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` These are ordinary Slovo source functions over `arg_result`, `parse_i32_result`, `parse_i64_result`, `parse_f64_result`, and `parse_bool_result` plus source `match`. The matching explicit import fixture, `examples/projects/std-import-process/`, now exercises the existing process wrappers, deterministic missing-argument cases, and deterministic invalid-present fallback behavior through `arg 0`. exp-67 does not add automatic standard-library imports, compiler-loaded standard-library source, process spawning, exit/status control, current directory APIs, shell parsing, subcommands, richer CLI framework APIs, rich host errors, new compiler-known `std.*` runtime names, stable ABI/layout/ownership, optimizer guarantees, or beta maturity. ## exp-66 (released experimental alpha) Release label: `exp-66` Release name: Standard Fs Typed Read Helpers Alpha Release date: 2026-05-20 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_66_STANDARD_FS_TYPED_READ_HELPERS_ALPHA.md`. exp-66 extends `std/fs.slo` with source-authored typed read result/fallback helpers over text-file reads plus the already promoted concrete parse result families: - `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` These are ordinary Slovo source functions over `read_text_result`, `parse_i32_result`, `parse_i64_result`, `parse_f64_result`, and `parse_bool_result` plus source `match`. The matching explicit import fixture, `examples/projects/std-import-fs/`, now exercises the existing fs wrappers, typed parse success cases, and deterministic invalid/missing fallback behavior. exp-66 does not add automatic standard-library imports, compiler-loaded standard-library source, binary file APIs, directory traversal, streaming file IO, async file IO, typed file writes, rich host errors, generic configuration helpers, new compiler-known `std.*` runtime names, stable ABI/layout/ownership, optimizer guarantees, or beta maturity. ## exp-65 (released experimental alpha) Release label: `exp-65` Release name: Standard Env Typed Helpers Alpha Release date: 2026-05-20 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_65_STANDARD_ENV_TYPED_HELPERS_ALPHA.md`. exp-65 extends `std/env.slo` with source-authored typed parse result/fallback helpers over environment lookup plus the already promoted concrete parse result families: - `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` These are ordinary Slovo source functions over `get_result`, `parse_i32_result`, `parse_i64_result`, `parse_f64_result`, and `parse_bool_result` plus source `match`. The matching explicit import fixture, `examples/projects/std-import-env/`, now exercises the existing env wrappers, typed parse success cases, and deterministic invalid/missing fallback behavior. exp-65 does not add automatic standard-library imports, compiler-loaded standard-library source, environment mutation, environment enumeration, environment writes, rich host errors, generic configuration helpers, new compiler-known `std.*` runtime names, stable ABI/layout/ownership, optimizer guarantees, or beta maturity. ## exp-64 (released experimental alpha) Release label: `exp-64` Release name: Standard Num Fallback Helpers Alpha Release date: 2026-05-20 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_64_STANDARD_NUM_FALLBACK_HELPERS_ALPHA.md`. exp-64 extends `std/num.slo` with source-authored checked conversion fallback helpers over the already promoted numeric result families: - `i64_to_i32_or` - `f64_to_i32_or` - `f64_to_i64_or` These are ordinary Slovo source functions over `i64_to_i32_result`, `f64_to_i32_result`, and `f64_to_i64_result` plus source `match`. The matching explicit import fixture, `examples/projects/std-import-num/`, now exercises both the existing conversion wrappers and the new fallback helpers. exp-64 does not add automatic standard-library imports, compiler-loaded standard-library source, unchecked narrowing conversions, saturating conversions, generic numeric traits, new compiler-known `std.*` runtime names, stable ABI/layout/ownership, optimizer guarantees, or beta maturity. ## exp-63 (released experimental alpha) Release label: `exp-63` Release name: Standard Fs Fallback Helpers Alpha Release date: 2026-05-20 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_63_STANDARD_FS_FALLBACK_HELPERS_ALPHA.md`. exp-63 extends `std/fs.slo` with source-authored text fallback/status helpers over the already promoted filesystem result families: - `read_text_or` - `write_text_ok` These are ordinary Slovo source functions over `read_text_result` and `write_text_result` plus source `match`. The matching explicit import fixture, `examples/projects/std-import-fs/`, now exercises both the existing fs wrappers and the new fallback/status helpers. exp-63 does not add automatic standard-library imports, compiler-loaded standard-library source, binary file APIs, directory traversal, streaming file IO, async file IO, rich host errors, new compiler-known `std.*` runtime names, stable ABI/layout/ownership, optimizer guarantees, or beta maturity. ## exp-62 (released experimental alpha) Release label: `exp-62` Release name: Standard Env Fallback Helpers Alpha Release date: 2026-05-20 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_62_STANDARD_ENV_FALLBACK_HELPERS_ALPHA.md`. exp-62 extends `std/env.slo` with source-authored environment fallback helpers over the already promoted `(result string i32)` environment lookup family: - `has` - `get_or` These are ordinary Slovo source functions over `get_result` plus source `match`. The matching explicit import fixture, `examples/projects/std-import-env/`, now exercises both the existing env wrappers and the new presence/fallback helpers. exp-62 does not add automatic standard-library imports, compiler-loaded standard-library source, environment mutation, environment enumeration, platform/configuration APIs, rich host errors, new compiler-known `std.*` runtime names, stable ABI/layout/ownership, optimizer guarantees, or beta maturity. ## exp-61 (released experimental alpha) Release label: `exp-61` Release name: Standard Process Fallback Helpers Alpha Release date: 2026-05-20 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_61_STANDARD_PROCESS_FALLBACK_HELPERS_ALPHA.md`. exp-61 extends `std/process.slo` with source-authored fallback helpers over the already promoted `(result string i32)` process argument family: - `arg_or` - `arg_or_empty` These are ordinary Slovo source functions over `arg_result` plus source `match`. The matching explicit import fixture, `examples/projects/std-import-process/`, now exercises both the existing process wrappers and the new fallback helpers. exp-61 does not add automatic standard-library imports, compiler-loaded standard-library source, option/flag parsing, subcommands, process spawning, exit/status control, shell parsing, rich host errors, new compiler-known `std.*` runtime names, stable ABI/layout/ownership, optimizer guarantees, or beta maturity. ## exp-60 (released experimental alpha) Release label: `exp-60` Release name: Standard String Fallback Helpers Alpha Release date: 2026-05-20 Status: released experimental alpha stdlib/source contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_60_STANDARD_STRING_FALLBACK_HELPERS_ALPHA.md`. exp-60 extends `std/string.slo` with source-authored fallback helpers over the already promoted concrete parse result families: - `parse_i32_or_zero` - `parse_i64_or_zero` - `parse_f64_or_zero` - `parse_bool_or_false` These are ordinary Slovo source functions over the existing `parse_*_result` helpers plus source `match` on the concrete `i32`, `i64`, `f64`, and `bool` result families. The matching explicit import fixture, `examples/projects/std-import-string/`, now exercises both the direct parse result wrappers and the new fallback helpers. exp-60 does not add automatic standard-library imports, compiler-loaded standard-library source, generic parse helpers, whitespace trimming, case-insensitive bool parsing, rich parse errors, new compiler-known `std.*` runtime names, stable ABI/layout/ownership, optimizer guarantees, or beta maturity. ## exp-59 (released experimental alpha) Release label: `exp-59` Release name: Hosted Build Optimization And Benchmark Publication Alpha Release date: 2026-05-20 Status: released experimental alpha documentation/tooling contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_59_HOSTED_BUILD_OPTIMIZATION_AND_BENCHMARK_PUBLICATION_ALPHA.md`. exp-59 does not change the exp-58 source-language surface. It records the paired Glagol exp-59 hosted-build optimization, refreshes the then-current benchmark methodology and local benchmark evidence, and adds a repo-local PDF rendering script for the whitepaper and manifest artifacts. exp-59 does not add source syntax, type forms, standard-library APIs, stable ABI/layout/ownership, optimizer guarantees, benchmark thresholds, cross-machine performance claims, package registry behavior, or beta maturity. ## exp-58 (released experimental alpha) Release label: `exp-58` Release name: Boolean Logic Alpha Release date: 2026-05-19 Status: released experimental alpha language contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_58_BOOLEAN_LOGIC_ALPHA.md`. exp-58 promotes `(and left right)`, `(or left right)`, and `(not value)` for boolean values. `and` and `or` lower through existing `if` semantics, so they short-circuit in the deterministic test runner and hosted lowering. The new supported fixture is `examples/supported/boolean-logic.slo`, with matching formatter coverage in `examples/formatter/boolean-logic.slo`. exp-58 does not add truthiness, variadic boolean operators, pattern guards, macro expansion, stable ABI/layout/ownership, optimizer guarantees, benchmark thresholds, or beta maturity. ## exp-57 (released experimental alpha) Release label: `exp-57` Release name: Integer Bitwise Alpha Release date: 2026-05-19 Status: released experimental alpha language/stdlib contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_57_INTEGER_BITWISE_ALPHA.md`. exp-57 promotes explicit `bit_and`, `bit_or`, and `bit_xor` binary heads for same-width signed integer operands: `i32` with `i32`, and `i64` with `i64`. The release also extends `std/math.slo` with `bit_and_i32`, `bit_or_i32`, `bit_xor_i32`, `bit_and_i64`, `bit_or_i64`, and `bit_xor_i64`. The new supported fixture is `examples/supported/integer-bitwise.slo`, with matching formatter coverage in `examples/formatter/integer-bitwise.slo`. exp-57 does not add shifts, bit-not, unsigned arithmetic, bit-width-specific integer families, floating-point bitwise operations, generic math, mixed numeric arithmetic, stable ABI/layout/ownership, optimizer guarantees, benchmark thresholds, or beta maturity. ## exp-56 (released experimental alpha) Release label: `exp-56` Release name: Integer Remainder Alpha Release date: 2026-05-19 Status: released experimental alpha language/stdlib contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_56_INTEGER_REMAINDER_ALPHA.md`. exp-56 promotes the `%` binary operator for same-width signed integer operands: `i32 % i32 -> i32` and `i64 % i64 -> i64`. The deterministic fixture covers positive and negative dividends for both widths. The release also extends `std/math.slo` with `rem_i32`, `is_even_i32`, `is_odd_i32`, `rem_i64`, `is_even_i64`, and `is_odd_i64`. The new supported fixture is `examples/supported/integer-remainder.slo`, with matching formatter coverage in `examples/formatter/integer-remainder.slo`. exp-56 does not add floating-point remainder, Euclidean modulo, unsigned arithmetic, bit operations, generic math, mixed numeric arithmetic, stable ABI/layout/ownership, optimizer guarantees, benchmark thresholds, or beta maturity. ## exp-55 (released experimental alpha) Release label: `exp-55` Release name: Result F64 Bool Source Flow Alpha Release date: 2026-05-19 Status: released experimental alpha language/tooling contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_55_RESULT_F64_BOOL_SOURCE_FLOW_ALPHA.md`. exp-55 promotes source constructors and source `match` payload bindings for the already existing concrete `(result f64 i32)` and `(result bool i32)` families. It also lets `std/cli.slo` propagate missing argument indexes as `err 1` for `arg_f64_result` and `arg_bool_result`. The new supported fixture is `examples/supported/result-f64-bool-match.slo`. exp-55 does not add 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. ## exp-54 (released experimental alpha) Release label: `exp-54` Release name: Standard CLI Typed Arguments Alpha Release date: 2026-05-19 Status: released experimental alpha language/tooling contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_54_STANDARD_CLI_TYPED_ARGUMENTS_ALPHA.md`. exp-54 extends `std/cli.slo` with `i64`, `f64`, and `bool` typed argument parse helpers while keeping the facade source-authored. The matching fixture imports the expanded `std.cli` helper list explicitly without a local copied module. `arg_i64_result` and `arg_i64_or_zero` propagate missing argument indexes through current source-supported result constructors. `arg_f64_result` and `arg_bool_result` return parse results over `std.process.arg`, so out-of-range argument indexes still follow the existing trap behavior. exp-54 does not add automatic standard-library imports, a `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. ## exp-53 (released experimental alpha) Release label: `exp-53` Release name: Standard CLI Source Facade Alpha Release date: 2026-05-19 Status: released experimental alpha language/tooling contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_53_STANDARD_CLI_SOURCE_FACADE_ALPHA.md`. exp-53 adds `std/cli.slo`, a narrow source-authored CLI facade that composes `std.process` and `std.string` source modules. The matching fixture imports `std.cli` explicitly without a local copied module. The new fixture is `examples/projects/std-import-cli/`. exp-53 does not add automatic standard-library imports, a `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. ## exp-52 (released experimental alpha) Release label: `exp-52` Release name: Standard Process Facade Source Search Alpha Release date: 2026-05-19 Status: released experimental alpha language/tooling contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_52_STANDARD_PROCESS_FACADE_SOURCE_SEARCH_ALPHA.md`. exp-52 adds `std/process.slo`, a narrow source-authored facade over already promoted process argument runtime calls. The matching fixture imports `std.process` explicitly without a local copied module. The new fixture is `examples/projects/std-import-process/`. exp-52 does not add automatic standard-library imports, a `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. ## exp-51 (released experimental alpha) Release label: `exp-51` Release name: Standard Library Path List Alpha Release date: 2026-05-19 Status: released experimental alpha language/tooling contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_51_STANDARD_LIBRARY_PATH_LIST_ALPHA.md`. exp-51 refines explicit standard-source discovery so `SLOVO_STD_PATH` may name an ordered OS path list of standard-library roots. This allows an override root to sit before an installed or checkout root without copying the entire `std/` tree. exp-51 does not add automatic standard-library imports, a `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. ## exp-50 (released experimental alpha) Release label: `exp-50` Release name: Installed Standard Library Discovery Alpha Release date: 2026-05-19 Status: released experimental alpha language/tooling contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_50_INSTALLED_STANDARD_LIBRARY_DISCOVERY_ALPHA.md`. exp-50 extends the explicit standard-source import contract to installed toolchain discovery. Glagol may now discover staged `std/*.slo` files from an installed `share/slovo/std` layout near the compiler executable, while keeping `SLOVO_STD_PATH` and checkout discovery available. exp-50 does not add automatic standard-library imports, a `std.slo` aggregator, package registry behavior, lockfiles, package std dependencies, new standard-library modules, stable install layout guarantees, stable ABI/layout/ownership, optimizer guarantees, benchmark thresholds, or beta maturity. ## exp-49 (released experimental alpha) Release label: `exp-49` Release name: Standard IO Facade Source Search Alpha Release date: 2026-05-19 Status: released experimental alpha language/tooling contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_49_STANDARD_IO_FACADE_SOURCE_SEARCH_ALPHA.md`. exp-49 extends explicit project-mode standard-library source search to `std.io`. `std/io.slo` now carries an export list, and the matching fixture imports the module without a local copy. The new fixture is `examples/projects/std-import-io/`. exp-49 does not add automatic standard-library imports, a `std.slo` aggregator, package registry behavior, installed toolchain stdlib paths, new compiler-known IO names, formatted output APIs, stable ABI/layout/ownership, optimizer guarantees, benchmark thresholds, or beta maturity. ## exp-48 (released experimental alpha) Release label: `exp-48` Release name: Standard Core Facade Source Search Alpha Release date: 2026-05-19 Status: released experimental alpha language/tooling contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_48_STANDARD_CORE_FACADE_SOURCE_SEARCH_ALPHA.md`. exp-48 extends explicit project-mode standard-library source search to the pure source facade modules `std.string` and `std.num`. `std/string.slo` and `std/num.slo` now carry export lists, and the matching fixtures import those modules without local copies. The new fixtures are `examples/projects/std-import-string/` and `examples/projects/std-import-num/`. exp-48 does not add automatic standard-library imports, a `std.slo` aggregator, package registry behavior, installed toolchain stdlib paths, generic parse/format APIs, broad numeric casts, stable ABI/layout/ownership, optimizer guarantees, benchmark thresholds, or beta maturity. ## exp-47 (released experimental alpha) Release label: `exp-47` Release name: Standard Host Facade Source Search Alpha Release date: 2026-05-19 Status: released experimental alpha language/tooling contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_47_STANDARD_HOST_FACADE_SOURCE_SEARCH_ALPHA.md`. exp-47 extends explicit project-mode standard-library source search to the host facade modules `std.time`, `std.random`, `std.env`, and `std.fs`. `std/time.slo`, `std/random.slo`, `std/env.slo`, and `std/fs.slo` now carry export lists, and the matching fixtures import those modules without local copies. The new fixtures are `examples/projects/std-import-time/`, `examples/projects/std-import-random/`, `examples/projects/std-import-env/`, and `examples/projects/std-import-fs/`. exp-47 does not add automatic standard-library imports, a `std.slo` aggregator, workspace dependency syntax for std, package registry behavior, installed toolchain stdlib paths, broad host APIs, stable ABI/layout/ownership, optimizer guarantees, benchmark thresholds, or beta maturity. ## exp-46 (released experimental alpha) Release label: `exp-46` Release name: Workspace Standard Source Search Alpha Release date: 2026-05-19 Status: released experimental alpha language/tooling contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_46_WORKSPACE_STANDARD_SOURCE_SEARCH_ALPHA.md`. exp-46 extends explicit standard-library source search from single projects to workspace packages. The new fixture `examples/workspaces/std-import-option/` imports `(import std.option (...))` without a local copied `option.slo`. exp-46 does not add automatic standard-library imports, workspace dependency syntax for std, package registry behavior, installed toolchain stdlib paths, a `std.slo` aggregator, generic option helpers, broad standard-library APIs, stable ABI/layout/ownership, optimizer guarantees, benchmark thresholds, or beta maturity. ## exp-45 (released experimental alpha) Release label: `exp-45` Release name: Standard Result And Option Source Search Alpha Release date: 2026-05-19 Status: released experimental alpha language/tooling contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_45_STANDARD_RESULT_OPTION_SOURCE_SEARCH_ALPHA.md`. exp-45 extends the explicit standard-library source-search path to `std.result` and `std.option`. Ordinary project code may import `(import std.result (...))` and `(import std.option (...))`, and Glagol resolves those imports to repo-root `std/result.slo` and `std/option.slo` without local module copies. `std/result.slo` and `std/option.slo` now carry their own export lists. The matching contract fixtures are `examples/projects/std-import-result/` and `examples/projects/std-import-option/`. exp-45 does not add automatic standard-library imports, a `std.slo` aggregator, package registry behavior, workspace/package `std` imports, generic result helpers, generic option helpers, broad standard-library APIs, stable ABI/layout/ownership, optimizer guarantees, benchmark thresholds, or beta maturity. ## exp-44 (released experimental alpha) Release label: `exp-44` Release name: Standard Library Source Search Alpha Release date: 2026-05-19 Status: released experimental alpha language/tooling contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_44_STANDARD_LIBRARY_SOURCE_SEARCH_ALPHA.md`. exp-44 promotes the first explicit standard-library source search path: ordinary project code may import the staged math helpers with `(import std.math (...))` and Glagol resolves that import to repo-root `std/math.slo` without copying `math.slo` into the project. `std/math.slo` now carries its own export list so it can be imported as real source. The matching contract fixture is `examples/projects/std-import-math/`. exp-44 does not add automatic standard-library imports, a `std.slo` aggregator, package registry behavior, workspace/package `std` imports, broad standard-library APIs, stable ABI/layout/ownership, optimizer guarantees, benchmark thresholds, or beta maturity. ## exp-43 (released experimental alpha) Release label: `exp-43` Release name: Technical Whitepapers And Skills Alpha Release date: 2026-05-19 Status: released experimental alpha documentation/tooling contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_43_TECHNICAL_WHITEPAPERS_AND_SKILLS_ALPHA.md`. exp-43 publishes `docs/SLOVO_WHITEPAPER.md`, generated PDF publication artifacts, and a repository-local beta language-design skill under `.llm/skills/`. exp-43 does not add source syntax, type forms, standard-library APIs, stable ABI/layout/ownership, optimizer guarantees, benchmark thresholds, cross-machine performance claims, package registry behavior, or beta maturity. ## exp-42 (released experimental alpha) Release label: `exp-42` Release name: Hot Loop Benchmark Mode Alpha Release date: 2026-05-19 Status: released experimental alpha tooling contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_42_HOT_LOOP_BENCHMARK_MODE_ALPHA.md`. exp-42 keeps the Slovo language surface unchanged and pairs with Glagol benchmark-suite gates that separate `cold-process` timing from startup-amortized `hot-loop` timing. exp-42 does not add source syntax, type forms, standard-library APIs, stable ABI/layout/ownership, high-resolution timing APIs, optimizer guarantees, benchmark thresholds, cross-machine performance claims, package registry behavior, or beta maturity. ## exp-41 (released experimental alpha) Release label: `exp-41` Release name: Lisp Benchmark Comparison Alpha Release date: 2026-05-19 Status: released experimental alpha tooling contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_41_LISP_BENCHMARK_COMPARISON_ALPHA.md`. exp-41 keeps the Slovo language surface unchanged and pairs with Glagol benchmark-suite gates that compare two Lisp-family implementations: Clojure and Common Lisp/SBCL. exp-41 does not add source syntax, type forms, standard-library APIs, stable ABI/layout/ownership, optimizer guarantees, benchmark thresholds, cross-machine performance claims, package registry behavior, or beta maturity. ## exp-40 (released experimental alpha) Release label: `exp-40` Release name: Benchmark Suite And License Alpha Release date: 2026-05-19 Status: released experimental alpha governance/tooling contract. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_40_BENCHMARK_SUITE_AND_LICENSE_ALPHA.md`. exp-40 adds project licensing as `MIT OR Apache-2.0`, records alpha/beta release naming criteria, and pairs with Glagol benchmark-suite gates for Slovo/C/Rust/Python/Clojure local timing comparisons. exp-40 does not add source syntax, type forms, standard-library APIs, stable ABI/layout/ownership, optimizer guarantees, benchmark thresholds, cross-machine performance claims, package registry behavior, or beta maturity. ## exp-39 (released experimental alpha) Release label: `exp-39` Release name: Standard Math Extensions And Benchmark Scaffold Alpha Release date: 2026-05-19 Status: released experimental alpha Slovo contract. Matching Glagol source checking, formatter, benchmark scaffold, gates, and review workflow are required before broader compiler-support claims. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_39_STANDARD_MATH_EXTENSIONS_AND_BENCHMARK_SCAFFOLD_ALPHA.md`. exp-39 extends staged `std/math.slo` with source-authored helpers for `i32`, `i64`, and finite `f64`: `neg_*`, `cube_*`, `is_zero_*`, `is_positive_*`, `is_negative_*`, and inclusive `in_range_*`. The existing exp-32 `abs`, `min`, `max`, `clamp`, and `square` helpers remain. The matching Glagol release adds a local `math-loop` benchmark scaffold for comparing Slovo executable timing against C, Rust, and Python on the same machine. Those timings are local tooling evidence only, not performance thresholds or optimizer guarantees. exp-39 does not add automatic `std` imports, repo-root `std/` search, compiler-loaded standard-library source, new compiler-known `std.*` operation names, trigonometry, `sqrt`, `pow`, modulo, bit operations, generic math, overloads, traits, mixed numeric arithmetic, optimizer guarantees, benchmark thresholds, stable standard-library APIs, stable ABI/layout/ownership, manifest schema changes, or beta maturity. ## exp-38 (released experimental alpha) Release label: `exp-38` Release name: Standard Host Source Facades Alpha Release date: 2026-05-19 Status: released experimental alpha Slovo contract. Matching Glagol source checking, formatter, gates, and review workflow are required before broader compiler-support claims. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_38_STANDARD_HOST_SOURCE_FACADES_ALPHA.md`. exp-38 adds staged source facades over already released host/runtime calls: - `std/random.slo` with `random_i32 : () -> i32` and `random_i32_non_negative : () -> bool` - `std/env.slo` with `get : (string) -> string` and `get_result : (string) -> (result string i32)` - `std/fs.slo` with `read_text`, `read_text_result`, `write_text_status`, and `write_text_result` The standard-library organization policy remains the exp-30 staged layout: flat `std/*.slo` facades now, with a future `std.slo` aggregator/reexport layer only after import/search semantics exist. This follows the Zig-like flat standard facade policy adapted to current Slovo. exp-38 does not add automatic `std` imports, repo-root `std/` search, compiler-loaded standard-library source, new compiler-known `std.*` operation names, standard-runtime catalog entries, seed/range/bytes/floats/UUID/crypto random APIs, environment mutation/enumeration, rich host error ADTs, binary/directory/streaming/async filesystem APIs, stable standard-library APIs, stable ABI/layout/ownership, manifest schema changes, or beta maturity. ## exp-37 (released experimental alpha) Release label: `exp-37` Release name: Standard Time Source Facade Alpha Release date: 2026-05-19 Status: released experimental alpha Slovo contract. Matching Glagol source checking, formatter, gates, and review workflow are required before broader compiler-support claims. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_37_STANDARD_TIME_SOURCE_FACADE_ALPHA.md`. exp-37 adds the staged `std/time.slo` source facade with narrow wrappers over the already released exp-8 host time calls: - `monotonic_ms : () -> i32` - `sleep_ms_zero : () -> i32` `monotonic_ms` returns `std.time.monotonic_ms`. `sleep_ms_zero` calls `std.time.sleep_ms 0` and then returns `0`, because user-defined unit-return functions are not generally supported today and positive-duration timing assertions remain deferred. exp-37 adds no compiler-known runtime names and no entries to `STANDARD_RUNTIME.md`. The standard-library organization policy remains the exp-30 staged layout: flat `std/*.slo` facades now, with a future `std.slo` aggregator/reexport layer only after import/search semantics exist. This follows the Zig-like flat standard facade policy adapted to current Slovo. exp-37 does not add automatic `std` imports, repo-root `std/` search, compiler-loaded standard-library source, wall-clock/calendar/timezone APIs, high-resolution timers, async timers, cancellation, scheduling guarantees, new compiler-known `std.*` operation names, stable standard-library APIs, stable ABI/layout/ownership, manifest schema changes, or beta maturity. ## exp-36 (released experimental alpha) Release label: `exp-36` Release name: Standard Option Source Helpers Alpha Release date: 2026-05-19 Status: released experimental alpha Slovo contract. Matching Glagol source checking, formatter, gates, and review workflow are required before broader compiler-support claims. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_36_STANDARD_OPTION_SOURCE_HELPERS_ALPHA.md`. exp-36 adds the staged `std/option.slo` source facade with concrete helpers for the already supported `(option i32)` family: - `is_some_i32` - `is_none_i32` - `unwrap_some_i32` - `unwrap_or_i32` These are ordinary Slovo source functions over existing `is_some`, `is_none`, `unwrap_some`, and `if` behavior. `unwrap_or_i32` returns the `some` payload when present and otherwise returns the supplied fallback. exp-36 adds no compiler-known runtime names and no entries to `STANDARD_RUNTIME.md`. The standard-library organization policy remains the exp-30 staged layout: flat `std/*.slo` facades now, with a future `std.slo` aggregator/reexport layer only after import/search semantics exist. This is inspired by Zig's facade/reexport approach but adapted to current Slovo. exp-36 does not add automatic `std` imports, repo-root `std/` search, compiler-loaded standard-library source, generic option helpers, option payloads beyond `i32`, new compiler-known `std.*` operation names, stable standard-library APIs, stable ABI/layout/ownership, manifest schema changes, or beta maturity. exp-45 later promotes only explicit `std.option` source search for this helper module. ## exp-35 (released experimental alpha) Release label: `exp-35` Release name: Standard Result Bool Source Helpers Alpha Release date: 2026-05-19 Status: released experimental alpha Slovo contract. Matching Glagol source checking, formatter, gates, and review workflow are required before broader compiler-support claims. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_35_STANDARD_RESULT_BOOL_SOURCE_HELPERS_ALPHA.md`. exp-35 extends the staged `std/result.slo` source file with concrete bool helpers for the exp-34 returned `(result bool i32)` family: - `is_ok_bool` - `is_err_bool` - `unwrap_ok_bool` - `unwrap_err_bool` - `unwrap_or_bool` These are ordinary Slovo source functions over existing compiler-known `std.result.is_ok`, `std.result.is_err`, `std.result.unwrap_ok`, and `std.result.unwrap_err` support for the exp-34 bool parse result flow. `unwrap_or_bool` returns the ok payload when present and otherwise returns the supplied fallback. exp-35 adds no compiler-known runtime names and no entries to `STANDARD_RUNTIME.md`. At exp-35, Slovo still did not promote automatic `std` imports, a repo-root `std/` search path, compiler-loaded standard library source, source-authored generic result helpers, source constructors for `(result bool i32)`, or general source `match` over `(result bool i32)` beyond the compiler-supported fixture flow. exp-45 later promotes only explicit `std.result` source search for this helper module. exp-35 does not add supported/formatter example fixtures. It does not add generic `std.result.map`, generic `std.result.unwrap_or`, `std.result.and_then`, option helper names, broad result payload families, automatic standard-library imports, replacement of compiler-known `std.*` calls, new compiler-known `std.*` operation names, stable standard-library APIs, stable ABI/layout/ownership, manifest schema changes, or beta maturity. ## exp-34 (released experimental alpha) Release label: `exp-34` Release name: String Parse Bool Result Alpha Release date: 2026-05-19 Status: released experimental alpha Slovo contract. Matching Glagol implementation, tests, gates, and review workflow are required before broader compiler-support claims. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_34_STRING_PARSE_BOOL_RESULT_ALPHA.md`. exp-34 promotes exactly one string parse standard-runtime call: - `std.string.parse_bool_result : (string) -> (result bool i32)` The call parses exactly complete ASCII lowercase `true` and `false`. Success returns `ok true` or `ok false`; the empty string, uppercase or mixed-case text, leading or trailing whitespace, numeric text, and any other text return `err 1`. It does not trap for ordinary parse failure. The release adds byte-identical fixtures `examples/supported/string-parse-bool-result.slo` and `examples/formatter/string-parse-bool-result.slo`. exp-34 does not add generic parse APIs, trap-based parse, bool parsing beyond exact lowercase `true`/`false`, string/bytes parse, whitespace trimming, case-insensitive parsing, locale or Unicode boolean parsing, numeric boolean parsing, rich parse errors, source-authored `std/result.slo` bool wrappers, automatic `std` imports, compiler-loaded `std` source, stable helper ABI/layout/ownership, manifest schema changes, or beta maturity. ## exp-33 (released experimental alpha) Release label: `exp-33` Release name: Standard Result Source Helpers Alpha Release date: 2026-05-19 Status: released experimental alpha Slovo contract. Matching Glagol source checking, formatter, gates, and review workflow are required before broader compiler-support claims. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_33_STANDARD_RESULT_SOURCE_HELPERS_ALPHA.md`. exp-33 extends the staged `std/result.slo` source file with source helpers for already promoted concrete result families. It fills out missing `is_err_i64`, `unwrap_err_i64`, `is_err_string`, `unwrap_err_string`, `is_err_f64`, and `unwrap_err_f64` wrappers alongside the existing i32 helpers, and adds concrete `unwrap_or_i32`, `unwrap_or_i64`, `unwrap_or_string`, and `unwrap_or_f64` helpers. The numeric `unwrap_or_*` helpers are ordinary Slovo source functions implemented with `std.result.is_ok`, `std.result.unwrap_ok`, `if`, parameters, and explicit signatures. `unwrap_or_string` uses the existing `(result string i32)` `match` shape to return the payload or fallback. exp-33 adds no compiler-known runtime names and no entries to `STANDARD_RUNTIME.md`. At exp-33, Slovo still did not promote automatic `std` imports, a repo-root `std/` search path, or compiler-loaded standard library source. exp-45 later promotes explicit `std.result` source search while keeping automatic imports deferred. exp-33 does not add supported/formatter example fixtures. It does not add generic `std.result.map`, generic `std.result.unwrap_or`, `std.result.and_then`, option helper names, result payload families beyond the already promoted concrete ones, automatic standard-library imports, replacement of compiler-known `std.*` calls, new compiler-known `std.*` operation names, stable standard-library APIs, stable ABI/layout/ownership, manifest schema changes, or beta maturity. ## exp-32 (released experimental alpha) Release label: `exp-32` Release name: Standard Math Source Helpers Alpha Release date: 2026-05-19 Status: released experimental alpha Slovo contract. Matching Glagol source checking, formatter, gates, and review workflow are required before broader compiler-support claims. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_32_STANDARD_MATH_SOURCE_HELPERS_ALPHA.md`. exp-32 extends the staged `std/math.slo` source file with source-authored helpers expressible in current Slovo: - `abs_i64`, `min_i64`, `max_i64`, `clamp_i64`, and `square_i64` - `abs_f64`, `min_f64`, `max_f64`, and `clamp_f64` The existing exp-30 `i32` helpers and `square_f64` remain in place. The helpers use existing same-type arithmetic/comparison, `if`, literals, calls, and explicit signatures. They add no compiler-known runtime names and no entries to `STANDARD_RUNTIME.md`. At exp-32, Slovo did not yet promote automatic `std` imports, a repo-root `std/` search path, or compiler-loaded standard library source. exp-44 later promotes the first explicit `std.math` source-search path while keeping automatic imports deferred. exp-32 does not add supported/formatter example fixtures. It does not add automatic standard-library imports, replacement of compiler-known `std.*` calls, new compiler-known `std.*` operation names, a broad math library, trigonometry, `sqrt`, `pow`, `f32`, unsigned or narrower integers, generics, traits, overloads, mixed numeric arithmetic, numeric containers, stable standard-library APIs, stable ABI/layout/ownership, manifest schema changes, or beta maturity. ## exp-31 (released experimental alpha) Release label: `exp-31` Release name: Checked F64 To I64 Result Alpha Release date: 2026-05-19 Status: released experimental alpha Slovo contract. Matching Glagol implementation, tests, gates, and review workflow are required before broader compiler-support claims. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_31_CHECKED_F64_TO_I64_RESULT_ALPHA.md`. exp-31 promotes exactly one checked `f64` to `i64` result standard-runtime call: - `std.num.f64_to_i64_result : (f64) -> (result i64 i32)` The call returns `ok value` only when the input is finite, exactly integral, and within the signed `i64` range `-9223372036854775808` through `9223372036854775807`. It returns `err 1` for non-finite, fractional, or out-of-range input, without trapping for ordinary conversion failure. The release adds byte-identical fixtures `examples/supported/f64-to-i64-result.slo` and `examples/formatter/f64-to-i64-result.slo`, plus a `std/num.slo` wrapper over the promoted compiler-known call. The out-of-range fixture value is the formatter-stable conservative `9223372036854776000.0`; the accepted exact `9223372036854775808.0` spelling formats to that value. Detailed edge behavior near the `f64`/`i64` limits remains implementation-owned Glagol test coverage. exp-31 does not add unchecked casts, unchecked `f64` to `i64`, cast syntax, generic `cast_checked`, `f32`, unsigned or narrower integer families, additional numeric conversion families, mixed numeric arithmetic, broad math, numeric containers, stable helper ABI/layout/ownership, manifest schema changes, or beta maturity. ## exp-30 (released experimental alpha) Release label: `exp-30` Release name: Standard Library Source Layout Alpha Release date: 2026-05-19 Status: released experimental alpha Slovo contract. Matching Glagol implementation, tests, gates, and review workflow are required before broader compiler-support claims. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_30_STANDARD_LIBRARY_SOURCE_LAYOUT_ALPHA.md`. exp-30 establishes `std/` as the Slovo source home for staged standard library modules and examples. It adds `std/README.md`, `std/io.slo`, `std/string.slo`, `std/num.slo`, `std/result.slo`, and `std/math.slo`. `std/math.slo` contains narrow source-authored helpers expressible with the current language: `abs_i32`, `min_i32`, `max_i32`, `clamp_i32`, `square_i32`, and `square_f64`. The other `std/*.slo` files provide small source wrappers over already promoted compiler-known standard-runtime calls where current Slovo can express the wrapper cleanly. The release adds the conservative formatter example `examples/formatter/std-source-layout-alpha.slo`. It demonstrates the helper shape and layout contract without claiming repo-root `std` import/search support. exp-30 does not add automatic standard-library imports, replace compiler-known `std.*` calls with source implementations, add compiler-known `std.*` operation names, change `STANDARD_RUNTIME.md`, add generics, traits, overloads, package registry behavior, manifest schema changes, stable standard-library APIs, stable ABI/layout/ownership, broad math, trigonometry, `pow`, `sqrt`, `f32`, unsigned or narrower integers, mixed numeric arithmetic, numeric containers, or beta maturity. ## exp-29 (released experimental alpha) Release label: `exp-29` Release name: Numeric Struct Fields Alpha Release date: 2026-05-19 Status: released experimental alpha Slovo contract. Matching Glagol implementation, tests, gates, and review workflow are required before broader compiler-support claims. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_29_NUMERIC_STRUCT_FIELDS_ALPHA.md`. exp-29 promotes direct immutable struct field declarations whose field types are exactly `i64` or `f64`, alongside already supported direct `i32`, `bool`, immutable `string`, and current enum fields. It supports struct constructors with `i64` and finite `f64` field initializers, immutable value flow through locals, parameters, returns, and calls, field access returning `i64` or `f64`, and use of accessed fields with existing same-type arithmetic/comparison and existing numeric print/format helpers where already supported. The release adds byte-identical fixtures `examples/supported/numeric-struct-fields.slo` and `examples/formatter/numeric-struct-fields.slo`. exp-29 keeps the exp-20 finite-only `f64` policy. It does not add 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, or beta maturity. ## exp-28 (released experimental alpha) Release label: `exp-28` Release name: String Parse F64 Result Alpha Release date: 2026-05-19 Status: released experimental alpha Slovo contract. Matching Glagol implementation, tests, gates, and review workflow are required before broader compiler-support claims. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_28_STRING_PARSE_F64_RESULT_ALPHA.md`. exp-28 promotes exactly one string parse standard-runtime call: - `std.string.parse_f64_result : (string) -> (result f64 i32)` The call parses complete finite ASCII decimal `f64` text. Success returns `ok value`; ordinary parse failure, non-finite text, trailing or leading unsupported characters, and out-of-domain input return `err 1`. It does not trap for ordinary parse or domain failure. The release adds byte-identical fixtures `examples/supported/string-parse-f64-result.slo` and `examples/formatter/string-parse-f64-result.slo`. exp-28 does not add generic parse, bool/string/bytes parse, locale parsing, Unicode digit parsing, underscores, rich parse errors, stable helper ABI/layout/ownership, result genericity, f64 containers, mixed numeric arithmetic, manifest schema changes, or beta maturity. ## exp-27 (released experimental alpha) Release label: `exp-27` Release name: Checked F64 To I32 Result Alpha Release date: 2026-05-19 Status: released experimental alpha Slovo contract. Matching Glagol implementation, tests, gates, and review workflow are required before broader compiler-support claims. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_27_F64_TO_I32_RESULT_ALPHA.md`. exp-27 promotes exactly one checked `f64` to `i32` result standard-runtime call: - `std.num.f64_to_i32_result : (f64) -> (result i32 i32)` The call returns `ok value` only when the input is finite, exactly integral, and within the signed `i32` range `-2147483648` through `2147483647`. It returns `err 1` for non-finite, fractional, or out-of-range input, without trapping for ordinary conversion failure. The release adds byte-identical fixtures `examples/supported/f64-to-i32-result.slo` and `examples/formatter/f64-to-i32-result.slo`. exp-27 does not add 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 helper ABI/layout/ownership, manifest schema changes, or beta maturity. ## exp-26 (released experimental alpha) Release label: `exp-26` Release name: F64 To String Alpha Release date: 2026-05-18 Status: released experimental alpha Slovo contract. Matching Glagol implementation, tests, gates, and review workflow are required before broader compiler-support claims. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_26_F64_TO_STRING_ALPHA.md`. exp-26 promotes exactly one finite `f64` formatting standard-runtime call: - `std.num.f64_to_string : (f64) -> string` The release adds byte-identical fixtures `examples/supported/f64-to-string.slo` and `examples/formatter/f64-to-string.slo`. exp-26 does not add `f32`, `f64` parse, generic format/display/interpolation, locale/base/radix/grouping/padding/precision controls, stable NaN/infinity text, implicit conversion, stable helper ABI/layout/ownership, manifest schema changes, or beta maturity. ## exp-25 (released experimental alpha) Release label: `exp-25` Release name: String Parse I64 Result Alpha Release date: 2026-05-18 Status: released experimental alpha Slovo contract. Matching Glagol implementation, tests, gates, and review workflow are required before broader compiler-support claims. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_25_STRING_PARSE_I64_RESULT_ALPHA.md`. exp-25 promotes exactly one string parse standard-runtime call: - `std.string.parse_i64_result : (string) -> (result i64 i32)` The call parses an entire non-empty ASCII signed decimal `i64` string with an optional leading `-`. Success returns `ok value`; parse failure or out-of-range input returns `err 1`. It does not trap for ordinary parse or range failure. The release also adds byte-identical fixtures `examples/supported/string-parse-i64-result.slo` and `examples/formatter/string-parse-i64-result.slo`. exp-25 does not add `f64` parse, generic parse APIs, a leading `+`, whitespace trimming, underscores, base/radix prefixes, locale-aware parsing, Unicode digit parsing, rich parse errors, stable helper ABI/layout/ownership, manifest schema changes, or beta maturity. ## exp-24 (released experimental alpha) Release label: `exp-24` Release name: Integer To String Alpha Release date: 2026-05-18 Status: released experimental alpha Slovo contract. Matching Glagol implementation, tests, gates, and review workflow are required before broader compiler-support claims. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_24_INTEGER_TO_STRING_ALPHA.md`. exp-24 promotes exactly two integer formatting standard-runtime calls: - `std.num.i32_to_string : (i32) -> string` - `std.num.i64_to_string : (i64) -> string` Each call returns a decimal signed ASCII string for the input value. Negative values include a leading `-`; non-negative values have no leading `+`. The operations are compiler/runtime-backed for now and may later be rewritten in Slovo `std` source once the language can host them. The release also adds byte-identical fixtures `examples/supported/integer-to-string.slo` and `examples/formatter/integer-to-string.slo`. exp-24 does not add `f64` formatting, parse APIs, locale/base/radix/grouping or padding controls, generic format/display traits, implicit conversions, stable standard-library implementation source, stable helper ABI/layout and ownership, manifest schema changes, or beta maturity. ## exp-23 (released experimental alpha) Release label: `exp-23` Release name: Checked I64-To-I32 Conversion Alpha Release date: 2026-05-18 Status: released experimental alpha Slovo contract. Matching Glagol implementation, tests, gates, and review workflow are required before broader compiler-support claims. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_23_CHECKED_I64_TO_I32_CONVERSION_ALPHA.md`. exp-23 promotes exactly one checked narrowing standard-runtime call: - `std.num.i64_to_i32_result : (i64) -> (result i32 i32)` The call returns `ok value` when the signed `i64` input is within the signed `i32` range `-2147483648` through `2147483647`, and returns `err 1` when the input is outside that range. It does not trap on range failure. The release also adds byte-identical fixtures `examples/supported/checked-i64-to-i32-conversion.slo` and `examples/formatter/checked-i64-to-i32-conversion.slo`. The operation is an explicit call returning the existing concrete `(result i32 i32)` family. exp-23 does not add implicit numeric promotion, cast syntax, `std.num.cast`, checked cast generics, mixed numeric operators, any other narrowing conversion, `f64` conversions, unsigned or narrower integer families, numeric parse/format APIs, standard-library implementation promises, stable ABI/layout, manifest schema changes, or beta maturity. ## exp-22 (released experimental alpha) Release label: `exp-22` Release name: Numeric Widening Conversions Alpha Release date: 2026-05-18 Status: released experimental alpha Slovo contract. Matching Glagol implementation, tests, gates, and review workflow are required before broader compiler-support claims. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_22_NUMERIC_WIDENING_CONVERSIONS_ALPHA.md`. exp-22 promotes exactly three explicit standard-runtime numeric widening calls: - `std.num.i32_to_i64 : (i32) -> i64` - `std.num.i32_to_f64 : (i32) -> f64` - `std.num.i64_to_f64 : (i64) -> f64` The release also adds byte-identical fixtures `examples/supported/numeric-widening-conversions.slo` and `examples/formatter/numeric-widening-conversions.slo`. These operations are explicit calls. exp-22 does not add implicit numeric promotion, mixed `i32`/`i64`/`f64` arithmetic or comparison, narrowing conversions, checked numeric conversion result APIs, numeric cast syntax, `f32`, unsigned or narrower integer families, numeric parse/format APIs, stable floating rounding or formatting guarantees, stable ABI/layout, manifest schema changes, or beta maturity. ## exp-21 (released experimental contract) Release label: `exp-21` Release name: I64 Numeric Primitive Alpha Release date: 2026-05-18 Status: released experimental Slovo contract. Matching Glagol implementation, tests, gates, and review workflow are required before broader compiler-support claims. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_21_I64_NUMERIC_PRIMITIVE_ALPHA.md`. exp-21 allows direct `i64` value flow, explicit signed decimal `i64` literal atoms, same-type arithmetic/comparison, and one print operation: ```slo (fn adjust ((value i64) (delta i64)) -> i64 (+ value delta)) ``` It promotes: - direct `i64` function parameters and returns - immutable `let` locals declared as `i64` - explicit signed decimal `i64` literal atoms such as `2147483648i64`, `42i64`, and `-7i64` - calls passing and returning `i64` - same-type `i64` `+`, `-`, `*`, and `/` - same-type `i64` `=`, `<`, `>`, `<=`, and `>=` - `std.io.print_i64` - byte-identical fixtures `examples/supported/i64-numeric-primitive.slo` and `examples/formatter/i64-numeric-primitive.slo` Unsuffixed integer literals remain the existing `i32` surface, and `main` continues to return `i32`. exp-21 does not add `f32`, unsigned integers, narrower integer widths beyond existing `i32`, `char`, `bytes`, `decimal`, numeric casts, implicit promotion, mixed `i32`/`i64`/`f64` arithmetic, generic numeric operators, i64 arrays/vectors/options/results/enum payloads/struct fields, mutable `i64` locals, `parse_i64`, random `i64`, broader math APIs, stable divide-by-zero or overflow diagnostics, stable ABI/layout, manifest schema changes, or beta maturity. ## exp-20 (released experimental contract) Release label: `exp-20` Release name: F64 Numeric Primitive Alpha Release date: 2026-05-18 Status: released experimental Slovo contract. Matching Glagol implementation, tests, gates, and review workflow are required before broader compiler-support claims. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_20_F64_NUMERIC_PRIMITIVE_ALPHA.md`. exp-20 allows direct `f64` value flow, same-type arithmetic/comparison, and one print operation: ```slo (fn half ((value f64)) -> f64 (/ value 2.0)) ``` It promotes: - direct `f64` function parameters and returns - immutable `let` locals declared as `f64` - decimal `f64` literals in `f64` contexts - calls passing and returning `f64` - same-type `f64` `+`, `-`, `*`, and `/` - same-type `f64` `=`, `<`, `>`, `<=`, and `>=` - `std.io.print_f64` - byte-identical fixtures `examples/supported/f64-numeric-primitive.slo` and `examples/formatter/f64-numeric-primitive.slo` exp-20 does not add `f32`, `i64/u64/u32/u16/u8/i16/i8`, `char`, `bytes`, `decimal`, numeric casts, implicit promotion, mixed `i32`/`f64` arithmetic, generic numeric operators, f64 arrays/vectors/options/results/enum payloads/ struct fields, mutable `f64` locals, `parse_f64`, random floats, broader math library calls, stable NaN/infinity/rounding semantics, stable print text formatting beyond newline-terminated output, stable ABI/layout, manifest schema changes, or beta maturity. ## exp-19 (released experimental contract) Release label: `exp-19` Release name: Primitive Struct Fields Alpha Release date: 2026-05-18 Status: released experimental Slovo contract. Matching Glagol implementation, tests, gates, and review workflow are required before broader compiler-support claims. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_19_PRIMITIVE_STRUCT_FIELDS_ALPHA.md`. exp-19 allows direct `bool` and immutable `string` field types alongside already supported direct `i32` fields and exp-18 direct enum fields: ```slo (struct PrimitiveRecord (id i32) (active bool) (label string)) ``` It promotes: - struct field declarations using direct `bool` and immutable `string` field types - struct construction with `i32`, `bool`, and immutable `string` field values - field access returning the declared primitive field type - bool field access in existing predicate positions - string field access in existing string equality and `std.string.len` - immutable local, parameter, return, call, test, and `main` flow for structs carrying primitive fields - byte-identical fixtures `examples/supported/primitive-struct-fields.slo` and `examples/formatter/primitive-struct-fields.slo` exp-19 does not add arrays, vectors, options, or results containing primitive-field structs, primitive fields inside containers, nested structs, struct mutation, string mutation, ownership/cleanup guarantees beyond existing string behavior, broader string operations, printing beyond existing calls, generics, methods, traits, manifest schema changes, package/import widening, stable ABI/layout, or beta maturity. ## exp-18 (released experimental contract) Release label: `exp-18` Release name: Enum Struct Fields Alpha Release date: 2026-05-18 Status: released experimental Slovo contract. Matching Glagol implementation, tests, gates, and review workflow are required before broader compiler-support claims. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_18_ENUM_STRUCT_FIELDS_ALPHA.md`. exp-18 allows current user-defined enum types as direct struct field types: ```slo (enum Status Ready Blocked) (enum Reading Missing (Value i32)) (struct TaggedReading (status Status) (reading Reading)) ``` It promotes: - struct field declarations using current enum type names directly - struct construction with payloadless and unary `i32` enum field values - field access returning the declared enum type - same-enum equality on field access - exhaustive enum `match` on field access - immutable local, parameter, return, call, test, and `main` flow for structs carrying enum fields - byte-identical fixtures `examples/supported/enum-struct-fields.slo` and `examples/formatter/enum-struct-fields.slo` The enum surface is exactly exp-4 payloadless variants plus exp-16 unary `i32` payload variants. exp-18 does not add payload types other than `i32`, multiple payloads, record variants, tuple variants beyond one `i32`, arrays, vectors, options, or results containing enum values, nested structs, struct mutation, enum mutation, printing, ordering, hashing, reflection, stable ABI/layout, manifest schema changes, import aliases/globs/re-exports, registry/package-manager claims, generics, or beta maturity. ## exp-17 (released experimental contract) Release label: `exp-17` Release name: Project Enum Imports Alpha Release date: 2026-05-18 Status: released experimental Slovo contract. Matching Glagol implementation, tests, gates, and review workflow are required before broader compiler-support claims. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_17_PROJECT_ENUM_IMPORTS_ALPHA.md`. exp-17 extends the existing explicit project/workspace module export and import lists so top-level user-defined enum names can cross local module boundaries: ```slo (module readings (export Reading)) (import readings (Reading)) ``` It promotes imported enum type use in: - function signatures - immutable locals - calls and returns - same-enum equality - exhaustive enum matches - qualified constructors The enum surface is exactly exp-4 payloadless variants plus exp-16 unary `i32` payload variants. Payloadless constructors remain zero-argument qualified constructors, and unary payload constructors still take exactly one `i32` argument. The exp-17 project fixture is: ```text examples/projects/enum-imports/slovo.toml examples/projects/enum-imports/src/readings.slo examples/projects/enum-imports/src/main.slo ``` exp-17 does not add payload types other than `i32`, multiple payloads, record variants, tuple variants beyond one `i32`, generics, containers, mutation, printing, ordering, hashing, reflection, unqualified variant constructors, stable ABI/layout, manifest schema changes, registry/package-manager claims, or beta maturity. ## exp-16 (released experimental contract) Release label: `exp-16` Release name: Unary I32 Enum Payloads Alpha Release date: 2026-05-18 Status: released experimental Slovo contract. Matching Glagol implementation, tests, gates, and review workflow are required before broader compiler-support claims. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_16_UNARY_I32_ENUM_PAYLOADS_ALPHA.md`. exp-16 extends user-defined enums to allow payloadless variants plus unary `i32` payload variants: ```slo (enum Reading Missing (Value i32) (Offset i32)) ``` It promotes: - qualified unary payload constructors such as `(Reading.Value value)` - payloadless constructors such as `(Reading.Missing)` unchanged - enum `match` arms with payloadless patterns and one immutable arm-local payload binding for payload variants - immutable local, parameter, return, call, test, and `main` flow for enum values - same-enum equality where payload variants compare by tag and payload, and payloadless variants compare by tag - byte-identical fixtures `examples/supported/enum-payload-i32.slo` and `examples/formatter/enum-payload-i32.slo` exp-16 does not add payload types other than `i32`, multiple payloads, record variants, tuple variants beyond one `i32`, string/bool/struct/enum payloads, generic enums, generic functions, type aliases, traits, methods, derives, wildcard/rest/nested enum patterns, pattern guards, enum payload mutation, enum values inside arrays/structs/options/results/vectors, enum printing, ordering, hashing, reflection, discriminants, stable ABI/layout, manifest schema changes, runtime ABI/layout claims, moving option/result to ordinary standard-library types, or beta maturity. ## exp-15 (released experimental contract) Release label: `exp-15` Release name: Result Helper Standard Names Alpha Release date: 2026-05-18 Status: released experimental Slovo contract with matching Glagol implementation, tests, gates, and review workflow. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_15_RESULT_HELPER_STANDARD_NAMES_ALPHA.md`. exp-15 is a narrow result helper standard-name alpha: - promotes preferred source-level names `std.result.is_ok`, `std.result.is_err`, `std.result.unwrap_ok`, and `std.result.unwrap_err` - accepts those names only for `(result i32 i32)` and `(result string i32)` - keeps legacy unqualified `is_ok`, `is_err`, `unwrap_ok`, and `unwrap_err` documented as compatibility syntax where already supported - reuses existing result observer and trap-based unwrap semantics - adds byte-identical fixtures `examples/supported/result-helpers.slo` and `examples/formatter/result-helpers.slo` - keeps `slovo.artifact-manifest` schema version `1` exp-15 does not add `std.result.map`, `std.result.unwrap_or`, `std.result.and_then`, option helper standard names, new payload families, generic result, user-defined error payloads, runtime ABI/layout claims, manifest schema changes, enum payloads, or beta maturity. ## exp-14 (released experimental contract) Release label: `exp-14` Release name: Standard Runtime Conformance Alignment Release date: 2026-05-18 Status: released experimental conformance alignment after matching Glagol exp-14 implementation, tests, focused conformance gate, full release gate, and review passed. This is experimental maturity and not a beta maturity claim. The normative release contract is `.llm/EXP_14_STANDARD_RUNTIME_CONFORMANCE_ALIGNMENT.md`. exp-14 is a conformance/readiness alignment seed over the released exp-13 surface: - catalogs every promoted compiler-known `std.*` operation through exp-13 in `STANDARD_RUNTIME.md` - keeps the supported fixture inventory explicit - adds byte-identical canonical fixtures for the already released exp-8 time operations: `examples/supported/time-sleep.slo` and `examples/formatter/time-sleep.slo` - requires Slovo/Glagol supported and formatter fixtures to stay byte-aligned where matching files exist - requires a fresh-project workflow covering `new`, `check`, `fmt --check`, `test`, `doc`, and `build` where the hosted toolchain exists - requires an integrated workflow over already released features: modules/ imports, tests, strings, `std.string.concat`, `std.string.parse_i32_result`, result `match`, `(vec i32)`, enum `match`, and `std.io.print_i32` - keeps the release gate strict: diff checks, `cargo fmt --check`, `cargo test`, ignored promotion gate, binary smoke, LLVM smoke, and review `PASS` The exp-14 release gate passed with Slovo/Glagol diff checks, `cargo fmt --check`, `cargo test`, ignored promotion gate, binary smoke, LLVM smoke, focused conformance gate, and review `PASS`. exp-14 adds no new source syntax, type forms, runtime APIs, compiler-known `std.*` names, standard library functions, manifest schema version, ABI/layout promise, runtime headers/libraries, or beta maturity. ## exp-13 (released experimental contract) Release label: `exp-13` Release date: 2026-05-18 Status: released experimental compiler support after matching Glagol exp-13 implementation, tests, review, and full release gate coverage passed. This is not a beta maturity claim. The normative release contract is `.llm/EXP_13_STRING_PARSE_I32_RESULT_ALPHA.md`. exp-13 is a narrow string parse i32 result alpha: - `std.string.parse_i32_result: (string) -> (result i32 i32)` - parses the entire input string as ASCII decimal signed `i32` - accepts an optional leading `-` and at least one ASCII digit - success returns `(ok i32 i32 value)` - empty input, non-digits, plus signs, whitespace, trailing bytes, non-ASCII digits, and out-of-range values return `(err i32 i32 1)` - only ordinary parse error code `err 1` is promised - the operation composes structurally with `std.io.read_stdin_result` by matching the stdin result and parsing only the `ok` string payload Release fixtures: ```text examples/supported/string-parse-i32-result.slo examples/formatter/string-parse-i32-result.slo ``` exp-13 does not add trap-based `std.string.parse_i32`, parsing floats, bools, strings, or bytes, whitespace/locale/base-prefix/underscore/plus-sign parsing, generic parse APIs, parse error messages or richer codes, Unicode digit parsing, string indexing or slicing, tokenizer/scanner APIs, stdin line APIs, stable helper ABI/layout, manifest schema fields, or beta maturity. ## exp-12 (released experimental contract) Release label: `exp-12` Release date: 2026-05-18 Status: released experimental compiler support after matching Glagol exp-12 implementation, tests, review, and release gate coverage passed. This is not a beta maturity claim. The normative release contract is `.llm/EXP_12_STDIN_RESULT_ALPHA.md`. exp-12 is a narrow standard input result alpha: - `std.io.read_stdin_result: () -> (result string i32)` - reads remaining standard input as text - success returns `(ok string i32 text)` - ordinary EOF with no bytes is success with the empty string - ordinary host/input failure returns `(err string i32 1)` - only ordinary failure code `err 1` is promised - Glagol test-runner behavior may use an implementation-owned fixed input string as `ok` - existing exp-3 and exp-10 host calls stay unchanged Release fixtures: ```text examples/supported/stdin-result.slo examples/formatter/stdin-result.slo ``` exp-12 does not add trap-based `std.io.read_stdin`, line iteration, prompt APIs, terminal mode, binary stdin, streaming, async, encoding/Unicode promises beyond existing string bytes, stable helper ABI/layout, manifest schema changes, or beta maturity. ## exp-11 (released experimental contract) Release label: `exp-11` Release date: 2026-05-18 Status: released experimental compiler support after matching Glagol exp-11 implementation, tests, review, and release gate coverage passed. This is not a beta maturity claim. The normative release contract is `.llm/EXP_11_BASIC_RANDOMNESS_ALPHA.md`. exp-11 is a narrow basic randomness alpha: - `std.random.i32: () -> i32` - returns a non-negative implementation-owned pseudo-random or host-random `i32` - suitable only for basic CLI use - deterministic-enough Glagol test-runner behavior through an implementation-owned non-negative sample or sequence - runtime/host inability to produce a value traps exactly as `slovo runtime error: random i32 unavailable` Release fixtures: ```text examples/supported/random.slo examples/formatter/random.slo ``` exp-11 does not claim seed APIs, cryptographic/security suitability, bytes APIs, ranges or bounds arguments, floats, random strings, UUIDs, broad `std.random.*`, randomness-specific manifest fields, stable ABI/layout/helper symbols, or beta maturity. ## exp-10 (released experimental contract) Release label: `exp-10` Release date: 2026-05-18 Status: released experimental compiler support after matching Glagol exp-10 implementation, tests, review, and release gate coverage passed. This is not a beta maturity claim. The normative release contract is `.llm/EXP_10_RESULT_BASED_HOST_ERRORS_ALPHA.md`. exp-10 is a narrow result-based host errors alpha: - concrete `(result string i32)` only - `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 as `err 1` - exp-3 calls unchanged Release fixtures: ```text examples/supported/host-io-result.slo examples/formatter/host-io-result.slo ``` exp-10 does not claim general host error ADTs, `result string Error`, platform-specific codes, error messages, result equality/printing/mapping, broader host APIs, stable ABI/layout/helper symbols, manifest schema changes, or beta maturity. ## exp-9 (released experimental contract) Release label: `exp-9` Release date: 2026-05-18 Status: released experimental compiler support after matching Glagol exp-9 implementation, tests, review, and release gate coverage passed. This is not a beta maturity claim. The normative release contract is `.llm/EXP_9_RELIABILITY_PERFORMANCE_ECOSYSTEM_HARDENING.md`. exp-9 is hardening-only over the released exp-8 baseline. It requires reliability, performance, and ecosystem gates for the existing promoted experimental surface: property/fuzz-style parser, formatter, diagnostic, project graph, and runtime API tests where feasible; a source-reachable panic audit; benchmark fixtures or documented benchmark smoke; compatibility inventory for promoted experimental features; and a migration guide from `v2.0.0-beta.1` and exp releases. exp-9 adds no source language syntax, type-system behavior, standard-runtime names, package features, manifest schema versions, stable ABI/layout promises, public performance guarantees, or beta maturity. ## exp-8 (released experimental contract) Release label: `exp-8` Release date: 2026-05-18 Status: released experimental compiler support after matching Glagol exp-8 implementation, tests, review, and release gate coverage passed. This is not a beta maturity claim. ## Summary exp-8 narrows the broad concurrency and long-running programs roadmap category to host time and sleep alpha for long-running command-line programs: - compiler-known `std.time.monotonic_ms: () -> i32` - compiler-known `std.time.sleep_ms: (i32) -> unit` - host monotonic elapsed milliseconds with implementation-owned epoch - valid `sleep_ms 0` behavior - negative sleep durations rejected or trapped with `slovo runtime error: sleep_ms negative duration` - deterministic test-runner handling for `sleep_ms 0` - conservative structural or non-negative host-value test-runner support for `monotonic_ms` - standard-runtime time usage recorded in artifact manifests only if existing manifest patterns already support standard-runtime usage metadata The normative release contract is `.llm/EXP_8_HOST_TIME_SLEEP_ALPHA.md`. exp-8 adds no source language syntax and does not claim threads, channels, async, cancellation, actors, shared memory, data-race freedom, scheduling, timers, wall-clock/calendar/timezone APIs, high-resolution timers, signal handling, stable ABI/layout, or stable runtime helper symbols. ## exp-7 (released experimental contract) Release label: `exp-7` Release date: 2026-05-18 Status: released experimental compiler support after matching Glagol exp-7 implementation, tests, review, and release gate coverage. This is not a beta maturity claim. ## Summary exp-7 is deliberately limited to test selection and richer test-run metadata: - `glagol test --filter ` - legacy `glagol --run-tests --filter ` while Glagol keeps the legacy route - deterministic substring selection against test display names - selected tests execute in the existing deterministic order - non-selected discovered tests are skipped and counted - zero matches is a successful run with explicit discovered/selected/passed/ failed/skipped counts - additive text-output and artifact-manifest test-run metadata The normative contract is `.llm/EXP_7_TEST_SELECTION_ALPHA.md`. exp-7 adds no source language syntax and does not claim LSP, debug metadata, source maps, SARIF, watch/daemon protocols, documentation comments, lint categories, or benchmarks. ## exp-6 (released experimental contract) Release label: `exp-6` Release date: 2026-05-18 Status: released experimental compiler support after matching Glagol exp-6 implementation, tests, review, and release gate coverage. This is not a beta maturity claim. ## Summary exp-6 is deliberately limited to C FFI scalar imports: - top-level imported C function declarations such as `(import_c c_add ((lhs i32) (rhs i32)) -> i32)` - `i32`-only scalar parameters and `i32` or internal builtin `unit` returns - a conservative C symbol name subset matching the Slovo import name - lexical `(unsafe ...)` required at every imported C call site - explicit local C source linking through `glagol build --link-c ` - artifact-manifest recording of `foreign_imports` and `c_link_inputs` - an interpreter-style test-runner diagnostic when a test reaches an imported C call The normative contract is `.llm/EXP_6_C_FFI_SCALAR_IMPORTS_ALPHA.md`. The minimal fixture target is `examples/ffi/exp-6-c-add/`. ## exp-6 Deferrals exp-6 does not support pointer types, allocation/deallocation, raw unsafe head execution, ownership or lifetime rules, C exports, callbacks, headers, libraries, broad linker configuration, foreign globals, foreign structs, unions, enums, layout annotations, stable ABI, or stable layout. ## exp-5 (released experimental contract) Release label: `exp-5` Release date: 2026-05-18 Status: released experimental compiler support after matching Glagol exp-5 implementation, tests, review, and release gate coverage. This is not a beta maturity claim. ## Summary exp-5 is deliberately limited to local packages and workspace hygiene: - workspace `slovo.toml` manifests with explicit local member lists - package `slovo.toml` manifests with package name/version metadata - local path dependencies between workspace members - deterministic package graph ordering - explicit package-qualified imports for dependency modules - package graph recording in artifact manifests - diagnostics for missing package, dependency cycle, duplicate package name, path escape, invalid package name/version, and private visibility across package boundaries The normative contract is `.llm/EXP_5_LOCAL_PACKAGES_ALPHA.md`. The minimal fixture target is `examples/workspaces/exp-5-local/`. ## exp-5 Deferrals exp-5 does not support remote registries, version solving, lockfiles beyond deterministic local graph recording, build scripts, generated code, published packages, semver compatibility promises, macros, package-level generics, cross-package ABI stability, package re-exports, package archives, package publishing, registry authentication, feature flags, optional dependencies, dev dependencies, or target dependencies. ## exp-4 (released experimental contract) Release label: `exp-4` Release date: 2026-05-18 Status: released experimental compiler support after matching Glagol exp-4 implementation, tests, review, and release gate coverage. This is not a beta maturity claim. ## Summary exp-4 narrows user-defined data types to payloadless enums only: ```slo (enum Name VariantA VariantB) ``` Variant values are constructed through zero-argument qualified calls such as `(Name.VariantA)`. Enum values may flow through immutable locals, parameters, returns, calls, equality with `=`, and top-level tests. Enum `match` requires exhaustive payloadless variant arms: ```slo (match value ((Name.VariantA) body...) ((Name.VariantB) body...)) ``` Arms have one or more expression bodies and a common final result type, following the existing option/result match rule. ## Runtime And Layout The runtime/backend representation is compiler-owned. exp-4 makes no stable layout, discriminant value, ABI, helper-symbol, reflection, or conversion to `i32` promise. ## Fixtures exp-4 adds these current compiler-supported fixtures: ```text examples/supported/enum-basic.slo examples/formatter/enum-basic.slo ``` They are current exp-4 fixtures. ## exp-4 Deferrals exp-4 does not support payload variants, tuple variants, record variants, generic enums, generic functions, type aliases, traits, interfaces, protocols, methods, derives, variant payload binding, wildcard patterns, rest patterns, guards, nested patterns, enum values in arrays, enum values in struct fields, enum values in options, enum values in results, enum values in vectors, enum mutation, enum printing, enum ordering, enum hashing, reflection, explicit discriminants, enum constructors with arguments, unqualified variant constructors, stable ABI/layout, stable helper symbols, or moving option/result to ordinary standard-library types. ## exp-3 (released experimental contract) Release label: `exp-3` Release date: 2026-05-17 Status: released experimental compiler support after matching Glagol exp-3 implementation, tests, review, and release gate coverage. This is not a beta maturity claim. ## Summary exp-3 narrows standard IO and host environment support to exactly six compiler-known functions: ```text 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 ``` `std.io.eprint` writes to stderr without adding a newline. `std.process.argc` returns the process argument count, and `std.process.arg` returns a zero-based argument string. `std.env.get` returns the environment variable value, with a missing variable returning the empty string in this stage. `std.fs.read_text` reads a whole text file, and `std.fs.write_text` writes a whole string to a path. ## Runtime Behavior Out-of-range process argument access traps with: ```text slovo runtime error: process argument index out of bounds ``` Host file read failure traps with: ```text slovo runtime error: file read failed ``` Both messages are written to stderr with a trailing newline and exit with code `1`. `std.fs.write_text` returns `0` on success and `1` on host failure for this stage. ## Fixture Targets exp-3 adds these current compiler-supported fixture targets: ```text examples/supported/host-io.slo examples/formatter/host-io.slo ``` They are current exp-3 fixtures. ## exp-3 Deferrals exp-3 does not support networking, async IO, binary file APIs, directory traversal, terminal control, platform abstraction, general host error ADTs, `result string Error`, package interaction, stdin full read or line iteration, randomness, time, stable ABI/layout, or stable runtime helper symbols. ## exp-2 (released experimental contract) Release label: `exp-2` Release date: 2026-05-17 Status: released experimental compiler support after matching Glagol exp-2 implementation, tests, review, and release gate coverage. This is not a beta maturity claim. ## Summary exp-2 narrows collections to one concrete growable vector type: ```text (vec i32) ``` The only promoted operations are compiler-known standard-runtime names: ```text 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 ``` `std.vec.i32.append` returns a new immutable runtime-owned vector and does not mutate its input. `(vec i32)` values may flow through immutable locals, parameters, returns, calls, and top-level tests. Vector equality with `=` compares lengths and `i32` elements in order. ## Runtime Behavior Allocation failure traps with: ```text slovo runtime error: vector allocation failed ``` Index failure traps with: ```text slovo runtime error: vector index out of bounds ``` Both messages are written to stderr with a trailing newline and exit with code `1`. Vector cleanup is compiler/runtime-owned and not source-visible. ## Fixture Targets exp-2 adds these current compiler-supported fixture targets: ```text examples/supported/vec-i32.slo examples/formatter/vec-i32.slo ``` They are current exp-2 fixtures. ## exp-2 Deferrals exp-2 does not support generic vectors, element types other than `i32`, vector mutation, vector `var` or `set`, vector literals beyond empty/append construction, a `push` alias, nested vectors, vectors in arrays, structs, options, or results, iterators, slices, maps, sets, user-visible deallocation, stable ABI/layout/helper symbols, packages, or IO expansion. ## exp-1 (released experimental contract) Release label: `exp-1` Release date: 2026-05-17 Status: current experimental compiler support after matching Glagol exp-1 implementation, tests, review, and release gate coverage. ## Summary exp-1 is the first narrow step toward the future `1.0.0-beta` general-purpose language threshold. It promotes one heap-created string operation: ```slo (std.string.concat left right) ``` The exact signature is `(string, string) -> string`. The result is an immutable runtime-owned `string`. Existing string equality, `std.string.len`, `std.io.print_string`, string locals, parameters, returns, and calls returning `string` apply to runtime-owned strings as they do to literal-backed strings. No legacy `string_concat` alias is introduced. `std.string.concat` is a compiler-known standard-runtime name, not a user module, import, package dependency, foreign function, or stable C ABI symbol. ## Runtime Behavior Allocation failure traps with: ```text slovo runtime error: string allocation failed ``` The message is written to stderr with a trailing newline and exits with code `1`. Runtime-owned string cleanup is compiler/runtime-owned and not source-visible. ## Fixture Targets exp-1 adds these current compiler-supported fixture targets: ```text examples/supported/owned-string-concat.slo examples/formatter/owned-string-concat.slo ``` They are current exp-1 fixtures. ## exp-1 Deferrals exp-1 does not support mutable strings, string containers, string indexing or slicing, interpolation, formatting APIs, Unicode scalar/grapheme/display-width APIs, user-visible allocation or deallocation, file IO, environment variables, process arguments, time, randomness, packages, workspaces, generics, overloading, user-defined standard modules, growable collections, raw-memory execution, FFI, stable ABI, or stable layout. ## v2.0.0-beta.1 Release tag: `v2.0.0-beta.1` Release date: 2026-05-17 ## Summary Slovo `v2.0.0-beta.1` is an experimental integration/readiness release based on v1.7. It does not add new source language syntax or semantics unless that behavior is already implemented and gate-proven in Glagol. Experimental readiness means Slovo is usable for small real flat local projects with: - `glagol new` - `glagol check` - `glagol fmt --check` - `glagol fmt --write` - `glagol test` - `glagol build` - `glagol doc` - artifact manifests - JSON diagnostics - the release-gate script ## Experimental-Supported Surface The experimental language surface is the accumulated v1.1-v1.7 surface: `i32`, `bool`, builtin internal `unit`, top-level tests, locals, `if`, `while`, structs, fixed direct scalar arrays with checked indexing, string value flow, option/result values and the exact v1.4 match slice, standard-runtime alpha names, and the v1.6 lexical unsafe boundary with reserved unsafe heads. Basic IO is exactly `std.io.print_i32`, `std.io.print_string`, `std.io.print_bool`, and `std.string.len`. There is no file IO, environment variable IO, process argument IO, process control, or time/clock API in this experimental release. ## Experimental Deferrals Vectors and growable collections are deferred until future beta work unless separately implemented and gate-proven in Glagol. Fixed direct scalar arrays with checked indexing satisfy the experimental gate because this is an integration/readiness release for small flat local projects; growable collections require allocation, ownership/lifetime, mutation, capacity, diagnostics, lowering, runtime tests, and documentation that remain future beta work. Slovo `v2.0.0-beta.1` also makes no stable ABI/layout, FFI, raw-memory execution, LSP, debug metadata, source-map, file/env/process/time IO, or package registry promise. ## v1.7 Release tag: `v1.7` Release date: 2026-05-17 ## Summary Slovo v1.7 is a conservative developer experience hardening release over the v1.6 language contract. It adds tooling contracts only and does not promote new source language syntax, type-system behavior, runtime semantics, standard runtime names, ABI/layout guarantees, LSP support, stable debug metadata, or stable source maps. v1.7 promotes contracts for: - `glagol new [--name ]` - `glagol fmt --check ` - `glagol fmt --write ` - `glagol doc -o ` - a local release-gate script ## Project Scaffolding `glagol new` creates a valid v1.3-style project containing `slovo.toml` and `src/main.slo`. The generated main module must be small, testable, and limited to already-supported language forms. The command must fail without overwriting non-empty target directories. ## Formatter Modes Plain `glagol fmt ` remains stdout formatting and does not write the input file. `glagol fmt --check ` checks canonical formatting without writing. `glagol fmt --write ` writes canonical formatting for one file or for all immediate `.slo` project source modules in deterministic module order. ## Documentation Generator `glagol doc -o ` generates deterministic Markdown from current source structure: modules, imports/exports, structs, functions, and tests. It is a documentation generator, not a semantic reflection API. ## Release Gate The repo must provide a script or documented command entry point that runs the full v1 release gate locally without network, tag, push, or release-publication side effects. ## v1.7 Deferrals Slovo v1.7 does not support new language syntax or semantics, package management, dependency management, stdin formatting, recursive directory formatting, LSP, SARIF, watch mode, daemon protocols, debug adapters, stable debug metadata, DWARF, stable standalone source-map files, semantic reflection, runtime reflection, stable ABI, or stable layout. ## v1.6 Release tag: `v1.6` Release date: 2026-05-17 ## Summary Slovo v1.6 is a conservative memory and unsafe design slice over the v1.5 contract. It does not promote raw memory, pointers, allocation, deallocation, unchecked indexing, reinterpretation, or FFI execution. Lexical `(unsafe ...)` remains the only unsafe boundary. v1.6 reserves these compiler-known unsafe operation heads: - `alloc` - `dealloc` - `load` - `store` - `ptr_add` - `unchecked_index` - `reinterpret` - `ffi_call` Safe code using one of these heads must receive `UnsafeRequired` before normal call lookup. Code inside `(unsafe ...)` using one of these heads must receive `UnsupportedUnsafeOperation` until a future release defines syntax, type rules, lowering, runtime behavior, diagnostics, and tests. User functions, imports, exports, and parameters cannot shadow the reserved unsafe heads. Such declarations must be rejected with a structured duplicate/reserved-name diagnostic. ## Memory Direction v1.6 keeps safe values as the default Slovo memory model. Future memory work is staged toward affine ownership plus explicit unsafe regions, but v1.6 does not freeze ownership, pointer/reference types, allocator behavior, aliasing, cleanup, or unsafe-region escape rules. No stable ABI, layout, FFI, allocator, ownership, or raw-memory execution promise is made in v1.6. ## Supported Fixture Changes v1.6 adds no new supported source fixture because no raw unsafe operation is promoted. The supported unsafe fixture remains: ```text examples/supported/unsafe.slo ``` The speculative raw-memory example remains speculative: ```text examples/speculative/unsafe-memory.slo ``` ## v1.6 Deferrals Slovo v1.6 does not support pointer types, raw allocation, raw deallocation, pointer load/store, pointer arithmetic, unchecked indexing, raw reinterpretation, FFI calls, foreign symbol execution, stable object/library or header output, stable C ABI symbols, stable runtime layout, allocator APIs, ownership transfer, or safe abstractions over unsafe operations. ## v1.5 Release tag: `v1.5` Release date: 2026-05-17 ## Summary Slovo v1.5 is a conservative standard library alpha over the v1.4 contract. It promotes stable source-level standard-runtime names for existing runtime behavior without adding new data types, IO breadth, imports, packages, allocation, Unicode length semantics, or ABI promises. The matching Glagol v1.5 release implements this contract. v1.5 promotes: - `std.io.print_i32` - `std.io.print_string` - `std.io.print_bool` - `std.string.len` These are compiler-known v1.5 standard-runtime names. They do not require imports, do not name user modules, do not create package dependencies, and are not stable C ABI symbols. Legacy `print_i32`, `print_string`, `print_bool`, and `string_len` remain compatibility aliases. New examples prefer the promoted `std.*` names. ## Standard Runtime Alpha The promoted forms are: ```slo (std.io.print_i32 value) (std.io.print_string value) (std.io.print_bool value) (std.string.len value) ``` `std.io.print_i32` accepts exactly one `i32`, returns builtin `unit`, and keeps the same stdout behavior as legacy `print_i32`. `std.io.print_string` accepts exactly one `string`, returns builtin `unit`, and keeps the same stdout behavior and source string-literal constraints as legacy `print_string`. `std.io.print_bool` accepts exactly one `bool`, returns builtin `unit`, and keeps the same stdout behavior as legacy `print_bool`. `std.string.len` accepts exactly one `string`, returns `i32`, and keeps the same decoded-byte count semantics as legacy `string_len`. ## Diagnostics Unknown or unpromoted `std.*` calls must produce structured diagnostics. The suggested diagnostic code is `UnsupportedStandardLibraryCall`. Arity and type mismatches for promoted `std.*` calls use the existing arity/type diagnostics where applicable. Promoted `std.*` names are reserved from user function/export shadowing. ## Supported Fixture Additions v1.5 adds these Slovo fixtures: ```text examples/supported/standard-runtime.slo examples/formatter/standard-runtime.slo ``` ## v1.5 Deferrals Slovo v1.5 does not support `std.io.print_unit`, file IO, environment variables, process arguments, time or clocks, vectors/maps/sets or other 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. ## v1.4 Release tag: `v1.4` Release date: 2026-05-17 ## Summary Slovo v1.4 is a conservative core-language expansion over the v1.3 project-mode contract. It promotes source-level `match` only for existing `(option i32)` and `(result i32 i32)` values. It does not add user-defined enums/ADTs, generic payloads, mutation, vectors, broader numeric types, ownership, or layout/ABI promises. Assuming the matching Glagol v1.4 release implements this contract, v1.4 promotes: - `match` expressions over `(option i32)` and `(result i32 i32)` - exhaustive option arms: `some` and `none` - exhaustive result arms: `ok` and `err` - immutable arm payload binding for `some`, `ok`, and `err` - one-or-more expression arm bodies whose final expression is the arm value - common arm result typing for the whole match expression - named diagnostics for match subject, payload, exhaustiveness, duplicate arm, malformed pattern, arm type, binding collision, mutation, and container boundaries Existing `is_some`, `is_none`, `is_ok`, `is_err`, `unwrap_some`, `unwrap_ok`, and `unwrap_err` remain supported. New examples prefer `match` when control flow depends on the payload. ## Match Syntax Option matches use: ```slo (match value ((some payload) payload) ((none) 0)) ``` Result matches use: ```slo (match value ((ok payload) payload) ((err code) code)) ``` Payload bindings are immutable and scoped only to the selected arm. Arm bodies may contain one or more expressions. The final expression is the arm value, and all arms must produce the same result type. ## Supported Fixture Additions v1.4 adds these Slovo fixtures: ```text examples/supported/option-result-match.slo examples/formatter/option-result-match.slo ``` ## v1.4 Deferrals Slovo v1.4 does not support user-defined enums or algebraic data types, generic option/result payloads, non-`i32` payload matching, nested option/result payloads beyond current v1 limits, options/results in arrays or structs, option/result mutation, vectors, struct mutation, `i64`, general `(block ...)` expressions outside match arms, pattern guards, wildcard/rest patterns, destructuring structs/arrays/strings, standard-library error conventions, user-catchable exceptions, ownership promises, stable layout, or stable ABI. ## v1.3 Release tag: `v1.3` Release date: 2026-05-17 ## Summary Slovo v1.3 is a project-mode and local-modules release over the v1.2 language and toolchain contract. It does not add packages, dependencies, remote registries, version solving, workspaces, macros, public ABI, cross-package visibility, incremental builds, watch/LSP, path escapes, or generated code. Assuming the matching Glagol v1.3 release implements this contract, v1.3 promotes: - a project manifest named `slovo.toml` - a flat local source-root convention, defaulting to `src` - project mode for `glagol check`, `glagol test`, and `glagol build` - explicit imports between local project modules - explicit exports of top-level `fn` and `struct` names - deterministic project/module ordering - duplicate-name, missing-import, import-cycle, ambiguous-name, and visibility diagnostics - multi-file source spans and project artifact-manifest fields Single-file mode remains unchanged when a command receives one `.slo` file. ## Project Manifest The v1.3 manifest is exactly `slovo.toml`: ```toml [project] name = "example" source_root = "src" entry = "main" ``` `name` is required and must be a lowercase package-shaped identifier. `source_root` defaults to `src` and must stay under the project root. `entry` defaults to `main` and must be a flat module identifier. Unknown manifest sections or keys are diagnostics in v1.3. ## Project Layout And Modules Project module files are immediate `.slo` children of the source root: ```text . ├── slovo.toml └── src ├── main.slo └── math.slo ``` Each file declares one flat module whose name matches the file stem. A module with exports uses: ```slo (module math (export add_one)) ``` The only import form is: ```slo (import math (add_one)) ``` Only exported top-level `fn` and `struct` declarations are importable. Tests, locals, parameters, fields, builtins, intrinsics, generated declarations, and imported names are not exportable or importable. ## Project Commands Project mode is selected only when the input is a directory containing `slovo.toml` or the `slovo.toml` file itself: ```text glagol check glagol test glagol build -o ``` `check` validates every project module. `test` checks the project and runs top-level tests in deterministic module and source order. `build` checks the project, requires the entry module and supported `main` function, and produces one hosted native executable through the existing LLVM IR plus Glagol runtime C plus Clang path. ## Supported Fixture Additions v1.3 adds this Slovo project fixture: ```text examples/projects/basic/slovo.toml examples/projects/basic/src/main.slo examples/projects/basic/src/math.slo ``` exp-17 later adds this project enum-import fixture: ```text examples/projects/enum-imports/slovo.toml examples/projects/enum-imports/src/readings.slo examples/projects/enum-imports/src/main.slo ``` ## v1.3 Deferrals Slovo v1.3 does not support packages, dependencies, remote registries, version solving, lockfiles, workspaces, hierarchical modules, import aliases, glob imports, qualified names, re-exports, macros, public ABI, cross-package visibility, incremental builds, watch mode, LSP, SARIF, path escapes, generated code, project formatting, build profiles, cross-compilation, object output, library output, header output, stable debug metadata, DWARF, or standalone source maps. ## v1.2 Release tag: `v1.2` Release date: 2026-05-17 ## Summary Slovo v1.2 is a practical runtime values release over the v1.1 single-file toolchain contract. It does not add project mode, package management, imports, multi-file modules, stable ABI/layout promises, or a standard runtime. Assuming the matching Glagol v1.2 release implements this contract, v1.2 promotes: - immutable string `let` locals - string parameters and returns - calls returning strings - string equality with `=` - string byte length with `string_len` - top-level tests using string equality or string length comparisons - temporary compiler/runtime intrinsic `print_bool` - stable runtime trap messages and process exit behavior for array bounds and option/result unwrap failures ## Supported Fixture Additions v1.2 adds these Slovo fixtures: ```text examples/supported/string-value-flow.slo examples/supported/print-bool.slo examples/formatter/string-value-flow.slo examples/formatter/print-bool.slo ``` No `print_unit` fixture is added because unit printing remains unsupported. ## Runtime String Contract Strings remain immutable compiler/runtime values. Every promoted string value originates from a source string literal or from propagating such a value through an immutable local, parameter, return, or call result. `string_len` returns the decoded byte count before the trailing NUL byte. String equality compares decoded bytes before the trailing NUL byte. v1.2 does not promise Unicode normalization, grapheme counting, display width, arbitrary byte escapes, embedded NUL bytes, allocation, ownership, deallocation, stable ABI, or FFI behavior. String concatenation remains deferred in v1.2 because it requires allocation, ownership, lifetime, and deallocation semantics. exp-1 later stages only the narrow `std.string.concat` contract. ## Printing And Unit `print_bool` has exactly one `bool` argument, returns builtin `unit`, and writes `true\n` or `false\n`. `print_unit` remains unsupported. This keeps `unit` as an internal builtin result type for supported unit-producing body forms rather than making it a user-visible, storable, comparable, or test-final value. ## Runtime Errors Runtime traps are process-terminating runtime errors, not user-catchable Slovo exceptions. Required stderr messages are: ```text slovo runtime error: array index out of bounds slovo runtime error: unwrap_some on none slovo runtime error: unwrap_ok on err slovo runtime error: unwrap_err on ok ``` Each message is written with a trailing newline. The process exits with code `1`. `glagol test` reports a top-level test that triggers one of these runtime errors as a trapped test and exits with code `1`. ## v1.2 Deferrals Slovo v1.2 does not support mutable string locals, string assignment, string concatenation, string indexing or slicing, strings inside arrays/structs/ options/results, broader owned or heap strings, user-defined string runtime bindings, stable string ABI/layout, `print_unit`, user-visible `unit` values, project mode, imports, packages, or multi-file modules. exp-1 later stages only `std.string.concat` as a runtime-owned string operation. ## v1.1 Release tag: `v1.1` Release date: 2026-05-17 ## Summary Slovo v1.1 is a tooling release over the v1 language contract. It does not add new source language features, broaden the supported fixture set, or relax any v1 unsupported boundary. Assuming the matching Glagol v1.1 release implements the Slovo v1.1 toolchain contract, the stable user-facing tool surface is: ```text glagol check glagol fmt glagol test glagol build -o ``` These commands are single-file commands in v1.1. Project mode, package management, multi-file modules, stdin formatting, write-in-place formatting, test filtering, cross-compilation, optimization profiles, stable ABI promises, object/library output, C headers, FFI, LSP, SARIF, and daemon protocols remain deferred. ## Toolchain Contract v1.1 productizes the existing v1 language through a predictable CLI contract: - `check` parses, lowers, and type-checks one Slovo source file without producing primary artifacts. - `fmt` prints canonical formatted source for one file to stdout and does not modify the input file. - `test` runs top-level Slovo tests in one file and reports source failures, failed tests, and reported runtime traps as ordinary command failures. - `build` produces a hosted native executable for the current machine through the Glagol LLVM IR plus runtime C plus Clang pipeline. - `--json-diagnostics` requests newline-delimited JSON diagnostics on stderr. - `--manifest ` requests a `slovo.artifact-manifest` version `1` manifest describing the actual invocation outputs. - `--no-color`, `--help`, and `--version` are common command flags. Machine diagnostics remain schema `slovo.diagnostic` version `1`. Artifact manifests remain schema `slovo.artifact-manifest` version `1`. ## Stable Exit Codes Glagol v1.1 commands use this stable table: ```text 0 success 1 source parse, lowering, type, formatter, test failure, or unsupported form 2 command-line usage error 3 required toolchain component missing or unusable 4 internal compiler error 5 manifest or output artifact write failure ``` A failed Slovo test is exit code `1`. A missing hosted build dependency such as Clang is exit code `3`. Panics or impossible compiler states on supported inputs are release blockers and map to exit code `4` only as a containment path. ## Compatibility Aliases The canonical documented commands are `check`, `fmt`, `test`, and `build`. Glagol may retain pre-v1.1 developer commands or flags as compatibility aliases only when they route through the same diagnostics, manifest, and exit-code paths as the canonical commands and do not change semantics. Slovo v1.1 does not treat those aliases as primary user documentation, and exact alias names remain Glagol release evidence rather than new Slovo language surface. ## Native Build Boundary `glagol build -o ` is a hosted native build path, not a stable systems ABI promise. It proves that supported v1 programs can build and run as direct executables on the current host using documented Glagol runtime C inputs and the host Clang/linker environment. Required v1.1 native build smoke coverage includes `add`, `while`, array value flow, option payload flow, result payload flow, struct value flow, and string print. ## Release Gates Slovo-side gate: ```text git -C slovo diff --check ``` Glagol-side gates for the matching v1.1 release include the baseline test and format gates, CLI tests for all canonical commands, stable exit-code tests, JSON diagnostic snapshots, artifact manifest snapshots, hosted native build smokes, fixture-alignment checks, and release-note review for aliases and deferrals. No `v1.1` tag should be cut while required gates are failing, skipped, or blocked by review. ## v1 Release tag: `v1` Release date: 2026-05-17 ## Summary Slovo v1 extends the v0 kernel with practical value flow while preserving the manifest rule: a feature is supported only when the language contract, fixtures, formatter behavior, diagnostics, tests, and Glagol implementation agree. v1 keeps native executable output, stable ABI/layout promises, broad runtime bindings, raw memory, and FFI out of scope. The supported compiler path remains Slovo source through Glagol to textual LLVM IR, with native execution available through the explicit LLVM-plus-runtime Clang workflow. ## Supported Fixture Set These examples define the promoted Slovo v1 surface: ```text examples/supported/add.slo examples/supported/top-level-test.slo examples/supported/local-variables.slo examples/supported/if.slo examples/supported/while.slo examples/supported/struct.slo examples/supported/struct-value-flow.slo examples/supported/array.slo examples/supported/array-value-flow.slo examples/supported/array-direct-scalars.slo examples/supported/array-direct-scalars-value-flow.slo examples/supported/array-string.slo examples/supported/array-string-value-flow.slo examples/supported/option-result.slo examples/supported/option-result-flow.slo examples/supported/option-result-payload.slo examples/supported/string-print.slo examples/supported/unsafe.slo ``` Formatter fixtures under `examples/formatter/` define canonical v1 layout, including the promoted full-line comment stability fixture `examples/formatter/comments.slo`. Frozen v0 compatibility fixtures remain under `examples/compat/v0/`. ## Promoted v1 Language Surface - Struct value flow: immutable struct locals, struct parameters, struct returns, calls returning structs, and field access through stored values. - Fixed array value flow: immutable positive-length arrays over the current direct scalar families `i32`, `i64`, `f64`, `bool`, plus `string`, with immutable array locals, parameters, returns, calls returning arrays, and runtime-checked dynamic indexing on `i32` expressions. - Option/result value flow for `(option i32)` and `(result i32 i32)`: immutable locals, parameters, calls returning option/result values, tag observation, and explicit trap-based `i32` payload extraction with `unwrap_some`, `unwrap_ok`, and `unwrap_err`. - Narrow string runtime slice: direct source string literals passed to temporary compiler/runtime intrinsic `print_string`. - Lexical `unsafe` remains the accepted unsafe boundary, without raw memory or FFI operations. ### Runtime String Slice - Promotes the Slovo-side contract for immutable source string literals passed directly to temporary compiler/runtime intrinsic `(print_string value)`. - Defines the first runtime representation as a borrowed immutable NUL-terminated byte pointer to compiler-emitted static storage, with no user ownership, mutation, allocation, free, stable ABI, or broader runtime binding promise. - Adds `examples/supported/string-print.slo` and `examples/formatter/string-print.slo`. Still deferred at that stage: string locals, string function parameters or returns, string equality/comparison, strings inside arrays, structs, options, or results, slices, concatenation, length, indexing, ownership, user-defined string runtime bindings, and stable string ABI promises. Current exp-19 later promotes only direct immutable `string` struct fields. ## Tooling Contracts - Machine diagnostics use `slovo.diagnostic` version `1` with a root `(diagnostic ...)` form. - Artifact manifests use `slovo.artifact-manifest` version `1` for compiler outputs and test-report side channels. - Formatter output is stable for promoted formatter fixtures, preserves accepted full-line comment positions, rejects unsupported comment/layout positions with structured diagnostics, and does not promise width-based reflow. - Glagol keeps golden diagnostic fixtures for current explicitly rejected v1 boundaries and textual lowering-inspector golden fixtures for promoted v1 feature families. - Stable LLVM debug metadata, DWARF, standalone source-map files, JSON tooling output, direct native output, package layout, and stable ABI/layout remain deferred. ## Explicit Deferrals Slovo v1 does not support: - struct field/value mutation - full option/result matching, mapping, equality, printing, nested values, non-`i32` payloads, containers, or user-catchable payload traps - bool or unit printing, user-declared/stored `unit`, or broader standard runtime printing - full string value flow, ownership, slicing, indexing, equality/comparison, or user-defined runtime bindings - array mutation, arrays of unsupported element types, zero-length arrays, array equality, printing arrays, nested arrays, unchecked indexing, or stable array layout - pointer types, allocation, deallocation, load/store, pointer arithmetic, reinterpretation, raw memory operations, or FFI - JSON diagnostics or lowering-inspector output - macros, generics, package management, concurrency, direct machine-code backend, stable ABI, or stable layout ## v0 Release tag: `v0` Release date: 2026-05-16 Release commit: `d7a60ce` ## Summary Slovo v0 is the first released language contract. It turns the initial manifest, design laws, and compiler experiments into a strict supported subset with matching Glagol implementation coverage. The purpose of v0 is not broad application development. The purpose is to establish a clean, compiler-backed kernel that can be parsed, formatted, checked, tested, inspected, lowered, and emitted as LLVM IR. ## Supported Fixture Set These examples define the compiler-supported Slovo v0 surface: ```text examples/supported/add.slo examples/supported/top-level-test.slo examples/supported/local-variables.slo examples/supported/if.slo examples/supported/while.slo examples/supported/struct.slo examples/supported/array.slo examples/supported/option-result.slo examples/supported/unsafe.slo ``` Formatter fixtures live in `examples/formatter/` and define canonical layout for the same strict supported syntax. Frozen copies of the v0 supported and formatter fixtures live under `examples/compat/v0/` for post-v0 compatibility checks. Examples under `examples/speculative/` are design targets, not supported v0 compiler fixtures. ## Supported Language Surface Slovo v0 supports: - `(module name)` - top-level `(fn ...)` - top-level `(test "name" body... final-expression)` - top-level `(struct Name (field i32)...)` - explicit `i32` parameters and `i32` returns - direct `(option i32)` and `(result i32 i32)` constructor returns - integer literals and parameter references - binary `+` - equality comparison `=` - ordering comparison `<` - user function calls - temporary compiler intrinsic `print_i32` - local `i32` bindings with `let` and `var` - mutable local assignment with `set` - value-producing `if` - first-pass `while` as a non-final sequential body form - first-pass struct construction and immediate field access - first-pass fixed `i32` array construction - immutable fixed `i32` array locals - literal checked indexing - first-pass option/result constructors - lexical `unsafe` expression blocks containing otherwise supported safe forms ## Compiler Contract The matching compiler release is Glagol v0. Its implementation-facing surface is the `glagol` binary CLI. Glagol can: - emit LLVM IR for supported programs - format supported source - print parsed trees - inspect surface lowering - inspect checked lowering - check top-level tests - run top-level tests - emit structured diagnostics for unsupported or invalid source-reachable forms Native executable output is not part of the Slovo v0 language contract. v0 uses the explicit Glagol LLVM IR plus Clang runtime-linking workflow. ## Explicit Deferrals Slovo v0 does not support: - runtime string values - dynamic array indices - runtime array bounds traps - array parameters, returns, or mutation - slices - option/result locals, calls as values, matching, unwrap, equality, or printing - struct locals, parameters, returns, field mutation, nested fields, recursive structs, or methods - pointer types - raw allocation and deallocation - pointer load/store - pointer arithmetic - unchecked indexing behavior - reinterpretation - FFI - unsafe abstractions - stable ABI or layout promises - macros - generics - package management - ownership or affine resources - concurrency - direct machine-code backend ## Post-v0 Direction Post-v0 work starts in `SPEC-v1.md` and `.llm/V1_ROADMAP.md`. The first recommended v1 slice is struct value flow: struct locals, parameters, returns, and field access through stored struct values. This slice should be specified before implementation and must preserve the v0 support rule.