slovo/docs/language/RELEASE_NOTES.md

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

Unreleased

No unreleased changes yet.

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 <file.slo|project> builds and executes through the hosted native toolchain using .slovo/build when -o is not provided
• glagol clean <file.slo|project> 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 <payload> 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 <payload>) 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 <payload> 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:

(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:

(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:

(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:

(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:

(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:

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:

(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:

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:

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:

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:

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 <file.slo|project> --filter <substring>
• legacy glagol --run-tests --filter <substring> <file.slo> 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 <path>
• 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:

(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:

(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:

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:

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:

slovo runtime error: process argument index out of bounds

Host file read failure traps with:

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:

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:

(vec i32)

The only promoted operations are compiler-known standard-runtime names:

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:

slovo runtime error: vector allocation failed

Index failure traps with:

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:

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:

(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:

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:

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 <project-dir> [--name <name>]
• glagol fmt --check <file-or-project>
• glagol fmt --write <file-or-project>
• glagol doc <file-or-project> -o <dir>
• 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 <file.slo> remains stdout formatting and does not write the input file.

glagol fmt --check <file-or-project> checks canonical formatting without writing. glagol fmt --write <file-or-project> writes canonical formatting for one file or for all immediate .slo project source modules in deterministic module order.

Documentation Generator

glagol doc <file-or-project> -o <dir> 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:

examples/supported/unsafe.slo

The speculative raw-memory example remains speculative:

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:

(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:

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:

(match value
  ((some payload)
    payload)
  ((none)
    0))

Result matches use:

(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:

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:

[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:

.
├── slovo.toml
└── src
    ├── main.slo
    └── math.slo

Each file declares one flat module whose name matches the file stem. A module with exports uses:

(module math (export add_one))

The only import form is:

(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:

glagol check <project-root>
glagol test <project-root>
glagol build <project-root> -o <binary>

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:

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:

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:

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:

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:

glagol check <file.slo>
glagol fmt <file.slo>
glagol test <file.slo>
glagol build <file.slo> -o <binary>

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 <path> 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:

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 <file.slo> -o <binary> 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:

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:

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:

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.