sanjin 19b0454b3f Import Slovo 1.0.0-beta monorepo

2026-05-22 08:38:43 +02:00

167 KiB

Raw Blame History

Slovo Roadmap

This roadmap tracks the language contract. Glagol, in ../glagol, tracks the compiler implementation.

Guiding rule: the manifest wins. A feature is not accepted until it has surface syntax, typed-core meaning, lowering behavior, formatter behavior, diagnostics, and tests.

Long-horizon planning lives in .llm/GENERAL_PURPOSE_LANGUAGE_ROADMAP.md. It defines the experimental release train from the historical v2.0.0-beta.1 tag toward and beyond the first real general-purpose beta Slovo contract.

Current stage: 1.0.0-beta, released on 2026-05-21 as the first real general-purpose beta Slovo contract. The beta release integrates the completed unsigned u32/u64 numeric and staged-stdlib breadth scope from exp-125 with the already promoted project/package workflow, explicit std-source imports, concrete vector families, fixed arrays, structs, enums, result/ option, generated docs, formatter behavior, and structured diagnostics.

The final experimental precursor scope is exp-125, defined in .llm/EXP_125_UNSIGNED_U32_U64_NUMERIC_AND_STDLIB_BREADTH_ALPHA.md. Its unsigned direct-value flow, parse/format runtime lanes, and matching staged stdlib helper breadth are now absorbed into 1.0.0-beta.

The last tagged experimental alpha before beta is exp-124, defined in .llm/EXP_124_FIXED_ARRAY_ENUM_AND_STRUCT_ELEMENTS_ALPHA.md.

The previous released experimental alpha contract is exp-123, defined in .llm/EXP_123_OWNED_VECTOR_BENCHMARK_SUITE_EXTENSION_AND_WHITEPAPER_REFRESH_ALPHA.md, for one connected benchmark/publication refresh. It keeps the exp-121 language surface unchanged while refreshing the current whitepaper baseline and the documented nine-kernel benchmark suite around 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, with local-machine evidence only, no threshold claim, and no beta claim.

The previous released experimental alpha contract is exp-122, defined in .llm/EXP_122_COMPOSITE_DATA_BENCHMARK_SUITE_EXTENSION_AND_WHITEPAPER_REFRESH_ALPHA.md, for one connected benchmark/publication refresh. It kept the exp-121 language surface unchanged while refreshing the earlier whitepaper baseline and the documented seven-kernel benchmark suite around math-loop, branch-loop, parse-loop, array-index-loop, string-eq-loop, array-struct-field-loop, and enum-struct-payload-loop, with local-machine evidence only, no threshold claim, and no beta claim.

The previous released experimental alpha contract is exp-121, defined in .llm/EXP_121_NON_RECURSIVE_STRUCT_ENUM_PAYLOADS_ALPHA.md, for one connected broadening of the enum payload surface. It allows unary enum payload variants to use current known non-recursive struct types, while keeping exactly one payload per payload variant, a conservative same-payload-type-per-enum rule when payload variants are present, existing immutable enum flow through locals/params/returns/calls/tests/main, existing match payload binding and field access behavior, no enum equality requirement for struct-payload enums, no direct array/vec/option/result payloads, no recursion, and no beta claim.

The previous released experimental alpha contract is exp-120, defined in .llm/EXP_120_FIXED_ARRAY_STRUCT_FIELDS_ALPHA.md, for one connected broadening of the struct-field surface. It adds direct struct fields over the current promoted fixed immutable array family (array i32 N), (array i64 N), (array f64 N), (array bool N), and (array string N), while keeping array lengths positive only, arrays and structs immutable only, checked indexing on i32 expressions only, no field mutation, no array mutation, and no beta claim.

The earlier released experimental alpha contract is exp-119, defined in .llm/EXP_119_BENCHMARK_SUITE_EXTENSION_AND_WHITEPAPER_REFRESH_ALPHA.md, for one connected benchmark/publication refresh. It keeps the exp-118 language surface unchanged while refreshing the earlier whitepaper baseline and the documented five-kernel benchmark suite around math-loop, branch-loop, parse-loop, array-index-loop, and string-eq-loop, with local-machine evidence only, no threshold claim, and no beta claim.

The previous released experimental alpha contract is exp-118, defined in .llm/EXP_118_STRING_FIXED_ARRAYS_ALPHA.md, for one connected broadening of the fixed-array surface. It adds (array string N) alongside the earlier direct scalar array family, while keeping array lengths positive only, arrays immutable only, checked indexing on i32 expressions only, arrays in struct fields out of scope at that earlier boundary, and no beta claim.

The previous released experimental alpha contract is exp-117, defined in .llm/EXP_117_DIRECT_SCALAR_FIXED_ARRAYS_ALPHA.md, for one connected broadening of the fixed-array surface. It adds direct scalar element families i64, f64, and bool alongside the existing i32 lane, while keeping array lengths positive only, arrays immutable only, checked indexing on i32 expressions only, string arrays out of scope at that earlier boundary, and no beta claim.

The previous released experimental alpha contract is exp-116, defined in .llm/EXP_116_DIRECT_SCALAR_AND_STRING_ENUM_PAYLOADS_ALPHA.md, for one connected broadening of the enum payload surface. It adds unary direct i64, f64, bool, and string payload variants alongside payloadless variants and the existing unary i32 lane, while keeping exactly one payload per payload variant, a conservative same-payload-kind-per-enum rule, containers and composite payloads out of scope, and no beta claim.

The previous released experimental alpha contract is exp-115, defined in .llm/EXP_115_COMPOSITE_STRUCT_FIELDS_AND_NESTED_STRUCTS_ALPHA.md, for one connected broadening of the struct-field surface. It adds current concrete vec, option, and result families plus current known non-recursive struct types as direct struct fields, alongside the already-supported direct scalar, immutable string, and current enum field families, without broadening arrays as fields, field mutation, recursive/cyclic layouts, adding new runtime calls, or claiming beta maturity.

The previous released experimental alpha contract is exp-114, defined in .llm/EXP_114_MUTABLE_COMPOSITE_LOCALS_ALPHA.md, for one connected broadening of the local-value surface. It adds same-type mutable whole-value reassignment for string, the current concrete vec families, the current concrete option/result families, current known struct values, and current enum values, without broadening arrays, field/element/payload mutation, adding new runtime calls, or claiming beta maturity.

The previous released experimental alpha contract is exp-113, defined in .llm/EXP_113_MUTABLE_SCALAR_LOCALS_ALPHA.md, for one connected broadening of the local-value surface. It adds direct mutable bool, i64, and f64 locals declared with var and reassigned with set from already promoted same-type scalar expressions, without broadening string/vector/option/result/ struct/enum mutation, adding new runtime calls, or claiming beta maturity.

The previous released experimental alpha contract is exp-112, defined in .llm/EXP_112_IMMUTABLE_BOOL_LOCALS_ALPHA.md, for one connected broadening of the local-value surface. It adds direct immutable bool locals declared with let, initialized from already promoted bool expressions, and reusable in existing predicate, return, call, test, and main positions, without adding mutable bool locals, bool assignment, new runtime calls, or a beta claim.

The previous released experimental alpha contract is exp-111, defined in .llm/EXP_111_STANDARD_IO_STDIN_SOURCE_HELPERS_ALPHA.md, for one connected broadening of the concrete std.io facade. It adds 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, and read_stdin_bool_or while staying source-authored over the promoted std.io.read_stdin_result, std.string.parse_*_result, and exp-109 bridge helpers only, without adding compiler-known std names, generics, new runtime calls, or a beta claim.

The previous released experimental alpha contract is exp-109, defined in .llm/EXP_109_STANDARD_OPTION_AND_RESULT_BRIDGE_HELPERS_ALPHA.md, for one connected broadening of the concrete std.option and std.result facades. It adds some_or_err_i32, some_or_err_i64, some_or_err_f64, some_or_err_bool, some_or_err_string, ok_or_none_i32, ok_or_none_i64, ok_or_none_string, ok_or_none_f64, and ok_or_none_bool while staying source-authored over the existing concrete option/result families only, without adding compiler-known std names, generics, or a beta claim.

The previous released experimental alpha contract is exp-108, defined in .llm/EXP_108_STANDARD_VEC_STRING_F64_AND_BOOL_PREFIX_AND_SUFFIX_HELPERS_ALPHA.md, for one connected broadening of the concrete std.vec_string, std.vec_f64, and std.vec_bool facades. It adds starts_with, without_prefix, ends_with, and without_suffix to all three modules while staying source-authored, recursive, and immutable over the existing vec-string, vec-f64, and vec-bool runtime families only, without adding compiler-known std names, generics, or a beta claim.

The previous released experimental alpha contract is exp-106, defined in .llm/EXP_106_STANDARD_VEC_F64_AND_BOOL_OPTION_QUERY_HELPERS_ALPHA.md, for one connected broadening of the concrete std.vec_f64 and std.vec_bool facades. It adds index_option, first_option, last_option, index_of_option, and last_index_of_option to both modules while staying source-authored, recursive, and immutable over the existing vec-f64 and vec-bool runtime families and the already promoted concrete option families only, without adding compiler-known std names, generics, edit helpers, or a beta claim.

The previous released experimental alpha contract is exp-104, defined in .llm/EXP_104_STANDARD_VEC_BOOL_BASELINE_ALPHA.md, for the first usable std.vec_bool baseline facade over the sibling concrete (vec bool) runtime family. It freezes the baseline direct wrappers, builder helpers, query helpers, and the simple real-program helpers contains and count_of without widening compiler semantics beyond concrete (vec bool) flow and equality, and without adding generics, option/result helpers, transform/edit helpers, or a beta claim.

The previous released experimental alpha contract is exp-102, defined in .llm/EXP_102_STANDARD_OPTION_BOOL_AND_F64_BASELINE_ALPHA.md, for one connected broadening of the concrete std.option facade and the conservative option core-language slice. It adds the concrete (option f64) and (option bool) helper families to std/option.slo, broadens immutable value flow, extraction, and source-level match to those same families, and keeps the whole slice explicit and concrete without adding compiler-known std names, generic option semantics, or a beta claim.

The earlier released experimental alpha contract is exp-101, defined in .llm/EXP_101_STANDARD_VEC_STRING_OPTION_AND_TRANSFORM_HELPERS_ALPHA.md, for one connected broadening of the concrete std.vec_string facade. It adds the option-query helpers index_option, first_option, last_option, index_of_option, and last_index_of_option, plus the transform helpers concat, take, drop, reverse, and subvec, while staying source-authored, recursive, and immutable over the existing vec-string runtime family without adding compiler-known std names, generics, edit helpers, or a beta claim.

The earlier released experimental alpha contract is exp-100, defined in .llm/EXP_100_STANDARD_OPTION_STRING_BASELINE_ALPHA.md, for the first concrete (option string) baseline on top of the existing option slice. It broadens std/option.slo with concrete string constructors, observers, and fallback helpers, and broadens immutable option value flow, payload extraction, and source-level match to (option string) without adding compiler-known std names, generic option semantics, or a beta claim.

The earlier released experimental alpha contract is exp-99, defined in .llm/EXP_99_STANDARD_VEC_STRING_BASELINE_ALPHA.md, for the first usable std.vec_string baseline facade over the sibling concrete (vec string) runtime family. It adds the required direct wrappers, builder helpers, query helpers, and simple real-program helpers as one connected source-authored slice without widening compiler semantics beyond concrete (vec string) flow and equality, and without adding generics, helper families beyond the frozen baseline, or a beta claim.

The earlier released experimental alpha contract is exp-98, defined in .llm/EXP_98_STANDARD_VEC_I64_EDIT_HELPERS_ALPHA.md, for connected edit helpers on top of the existing std.vec_i64 baseline facade. It adds insert_at, insert_range, replace_at, replace_range, remove_at, and remove_range as one connected source-authored slice, keeps the full vec_i64 source family recursive and immutable, and does not add compiler-known std names, generics, or a beta claim.

The earlier released experimental alpha contract is exp-97, defined in .llm/EXP_97_STANDARD_VEC_I64_TRANSFORM_HELPERS_ALPHA.md, for narrow transform helpers on top of the existing std.vec_i64 baseline facade. It adds concat, take, drop, reverse, and subvec as one connected source-authored slice, keeps the full vec_i64 source family recursive and immutable, and does not add compiler-known std names, insert/replace/remove helpers, generics, or a beta claim.

The earlier released experimental alpha contract is exp-96, defined in .llm/EXP_96_STANDARD_VEC_I64_OPTION_QUERY_HELPERS_ALPHA.md, for concrete option-query helpers on top of the existing std.vec_i64 baseline facade. It adds index_option, first_option, last_option, index_of_option, and last_index_of_option as one connected source-authored slice, keeps the module self-contained through raw current (option i64) and (option i32) forms instead of std.option, keeps the full vec_i64 source family recursive and immutable, and does not add compiler-known std names, transform/range/edit helpers, generics, or a beta claim.

The earlier released experimental alpha contract is exp-95, defined in .llm/EXP_95_STANDARD_OPTION_I64_BASELINE_ALPHA.md, for the first concrete (option i64) baseline on top of the existing option slice. It broadens std/option.slo with the i64 constructor, observer, and fallback helper surface, and broadens immutable option value flow, payload extraction, and source-level match to (option i64) without adding compiler-known std names, generic option semantics, or a beta claim.

The earlier released exp-94 is defined in .llm/EXP_94_STANDARD_VEC_I64_BASELINE_ALPHA.md, for the first usable std.vec_i64 baseline facade over the sibling concrete (vec i64) runtime family. It adds the required direct wrappers, builder helpers, query helpers, and simple real-program helpers as one connected source-authored slice without widening compiler semantics or adding new Slovo-side compiler-known runtime names. It remains experimental maturity, not a beta claim.

The earlier released exp-93 is defined in .llm/EXP_93_STANDARD_VEC_I32_COUNT_OF_HELPER_ALPHA.md, for one new public std.vec_i32 helper, count_of, layered onto that same concrete runtime family without widening compiler semantics or adding new runtime names. It remains experimental maturity, not a beta claim.

The earlier released exp-92 is defined in .llm/EXP_92_STANDARD_VEC_I32_WITHOUT_PREFIX_HELPER_ALPHA.md, for one new public std.vec_i32 helper, without_prefix, layered onto that same concrete runtime family without widening compiler semantics or adding new runtime names. It remains experimental maturity, not a beta claim.

The earlier released exp-91 is defined in .llm/EXP_91_STANDARD_VEC_I32_WITHOUT_SUFFIX_HELPER_ALPHA.md, for one new public std.vec_i32 helper, without_suffix, layered onto that same concrete runtime family without widening compiler semantics or adding new runtime names. It remains experimental maturity, not a beta claim.

The earlier released exp-90 is defined in .llm/EXP_90_STANDARD_VEC_I32_ENDS_WITH_HELPER_ALPHA.md, for one new public std.vec_i32 helper, ends_with, layered onto that same concrete runtime family without widening compiler semantics or adding new runtime names. It remains experimental maturity, not a beta claim.

The earlier released exp-89 is defined in .llm/EXP_89_STANDARD_VEC_I32_STARTS_WITH_HELPER_ALPHA.md, for one new public std.vec_i32 helper, starts_with, layered onto that same concrete runtime family without widening compiler semantics or adding new runtime names. It remains experimental maturity, not a beta claim.

The earlier released exp-88 is defined in .llm/EXP_88_STANDARD_VEC_I32_REPLACE_RANGE_HELPER_ALPHA.md, for one new public std.vec_i32 helper, replace_range, layered onto that same concrete runtime family without widening compiler semantics or adding new runtime names. It remains experimental maturity, not a beta claim.

The earlier released exp-87 is defined in .llm/EXP_87_STANDARD_VEC_I32_INSERT_RANGE_HELPER_ALPHA.md, for one new public std.vec_i32 helper, insert_range, layered onto that same concrete runtime family without widening compiler semantics or adding new runtime names. It remains experimental maturity, not a beta claim.

The earlier released exp-86 is defined in .llm/EXP_86_STANDARD_VEC_I32_REMOVE_RANGE_HELPER_ALPHA.md, for one new public std.vec_i32 helper, remove_range, layered onto that same concrete runtime family without widening compiler semantics or adding new runtime names. It remains experimental maturity, not a beta claim.

The earlier released exp-85 is defined in .llm/EXP_85_STANDARD_VEC_I32_SUBVEC_HELPER_ALPHA.md, for one new public std.vec_i32 helper, subvec, layered onto that same concrete runtime family without widening compiler semantics or adding new runtime names. It remains experimental maturity, not a beta claim.

The earlier released exp-84 is defined in .llm/EXP_84_STANDARD_VEC_I32_INSERT_HELPER_ALPHA.md, for one new public std.vec_i32 helper, insert_at, layered onto that same concrete runtime family without widening compiler semantics or adding new runtime names. It remains experimental maturity, not a beta claim.

The earlier released exp-83 is defined in .llm/EXP_83_STANDARD_VEC_I32_REMOVE_HELPER_ALPHA.md, for one new public std.vec_i32 helper, remove_at, layered onto that same concrete runtime family without widening compiler semantics or adding new runtime names. It remains experimental maturity, not a beta claim.

The earlier released exp-82 is defined in .llm/EXP_82_STANDARD_VEC_I32_REPLACE_HELPER_ALPHA.md, for one new public std.vec_i32 helper, replace_at, layered onto that same concrete runtime family without widening compiler semantics or adding new runtime names. It remains experimental maturity, not a beta claim.

The earlier released exp-81 is defined in .llm/EXP_81_STANDARD_VEC_I32_RANGE_HELPER_ALPHA.md, for one new public std.vec_i32 helper, range, layered onto that same concrete runtime family without widening compiler semantics or adding new runtime names. It remains experimental maturity, not a beta claim.

The earlier released exp-80 is defined in .llm/EXP_80_STANDARD_VEC_I32_GENERATED_CONSTRUCTOR_HELPERS_ALPHA.md, for narrow generated constructor helpers layered onto the existing std.vec_i32 source facade over the promoted (vec i32) runtime family.

The earlier released exp-79 is defined in .llm/EXP_79_STANDARD_VEC_I32_TRANSFORM_HELPERS_ALPHA.md, for narrow recursive transform helpers layered onto the existing std.vec_i32 source facade over the promoted (vec i32) runtime family. It remains experimental maturity, not a beta claim.

The earlier released exp-78 is defined in .llm/EXP_78_STANDARD_CLI_LOCAL_SOURCE_FACADE_ALPHA.md, for the unchanged std.cli helper surface recorded as the Slovo-side contract for the sibling Glagol local-source gate over the existing std.process and std.string source facades. It remains experimental maturity, not a beta claim.

The earlier released exp-77 is defined in .llm/EXP_77_STANDARD_VEC_I32_OPTION_QUERY_HELPERS_ALPHA.md, for concrete option-returning query helpers layered onto the current std.vec_i32 source facade over the promoted (vec i32) runtime family. It remains experimental maturity, not a beta claim.

The earlier released exp-76 is defined in .llm/EXP_76_STANDARD_VEC_I32_SOURCE_HELPERS_ALPHA.md, for a concrete std.vec_i32 source facade over the current promoted (vec i32) runtime family. It remains experimental maturity, not a beta claim.

The earlier released exp-75 is defined in .llm/EXP_75_STANDARD_OPTION_CONSTRUCTORS_ALPHA.md, for source-authored concrete option constructors over the current promoted (option i32) family. It remains experimental maturity, not a beta claim. The earlier released exp-74 is defined in .llm/EXP_74_STANDARD_RESULT_CONSTRUCTOR_HELPERS_ALPHA.md, for source-authored concrete result constructors over the current promoted result families. It remains experimental maturity, not a beta claim.

The earlier released exp-73 is defined in .llm/EXP_73_STANDARD_IO_VALUE_HELPERS_ALPHA.md, for source-authored value-returning IO print helpers over the current promoted print runtime calls. It remains experimental maturity, not a beta claim.

The earlier released exp-72 is defined in .llm/EXP_72_STANDARD_CLI_CUSTOM_FALLBACK_HELPERS_ALPHA.md, for source-authored typed CLI argument custom-fallback helpers over the current argument lookup and concrete parse result families. It remains experimental maturity, not a beta claim.

The earlier released exp-71 is defined in .llm/EXP_71_STANDARD_PROCESS_CUSTOM_FALLBACK_HELPERS_ALPHA.md, for source-authored typed process argument custom-fallback helpers over the current argument lookup and concrete parse result families. It remains experimental maturity, not a beta claim.

The earlier released exp-70 is defined in .llm/EXP_70_STANDARD_FS_CUSTOM_FALLBACK_HELPERS_ALPHA.md, for source-authored typed filesystem read custom-fallback helpers over the current text-read and concrete parse result families. It remains experimental maturity, not a beta claim.

The earlier released exp-69 is defined in .llm/EXP_69_STANDARD_ENV_CUSTOM_FALLBACK_HELPERS_ALPHA.md, for source-authored typed environment parse custom-fallback helpers over the current environment lookup and concrete parse result families. It remains experimental maturity, not a beta claim.

The earlier released exp-68 is defined in .llm/EXP_68_STANDARD_STRING_CUSTOM_FALLBACK_HELPERS_ALPHA.md, for source-authored typed string parse custom-fallback helpers over the current concrete parse result families. It remains experimental maturity, not a beta claim.

The earlier released exp-67 is defined in .llm/EXP_67_STANDARD_PROCESS_TYPED_HELPERS_ALPHA.md, for source-authored typed process argument result/fallback helpers over the current argument lookup and concrete parse result families. It remains experimental maturity, not a beta claim.

The earlier released exp-66 is defined in .llm/EXP_66_STANDARD_FS_TYPED_READ_HELPERS_ALPHA.md, for source-authored typed filesystem read result/fallback helpers over the current text-read and concrete parse result families. It remains experimental maturity, not a beta claim.

The earlier released exp-65 is defined in .llm/EXP_65_STANDARD_ENV_TYPED_HELPERS_ALPHA.md, for source-authored typed environment parse result/fallback helpers over the current environment lookup and concrete parse result families. It remains experimental maturity, not a beta claim.

The earlier released exp-64 is defined in .llm/EXP_64_STANDARD_NUM_FALLBACK_HELPERS_ALPHA.md, for source-authored checked conversion fallback helpers over the current numeric result families. It remains experimental maturity, not a beta claim.

The earlier released exp-63 is defined in .llm/EXP_63_STANDARD_FS_FALLBACK_HELPERS_ALPHA.md, for source-authored filesystem fallback/status helpers over the current (result string i32) and (result i32 i32) families. It remains experimental maturity, not a beta claim.

The earlier released exp-62 is defined in .llm/EXP_62_STANDARD_ENV_FALLBACK_HELPERS_ALPHA.md, for source-authored environment presence/fallback helpers over the current (result string i32) family. It remains experimental maturity, not a beta claim.

The earlier released exp-61 is defined in .llm/EXP_61_STANDARD_PROCESS_FALLBACK_HELPERS_ALPHA.md, for source-authored process argument fallback helpers over the current (result string i32) family. It remains experimental maturity, not a beta claim.

The earlier released exp-60 is defined in .llm/EXP_60_STANDARD_STRING_FALLBACK_HELPERS_ALPHA.md, for source-authored string parse fallback helpers over the current concrete parse result families. It remains experimental maturity, not a beta claim.

The earlier released exp-59 is defined in .llm/EXP_59_HOSTED_BUILD_OPTIMIZATION_AND_BENCHMARK_PUBLICATION_ALPHA.md, for the earlier benchmark/publication baseline paired with Glagol exp-59. It keeps the exp-58 language surface unchanged and remains experimental maturity, not a beta claim.

The earlier released exp-58 is defined in .llm/EXP_58_BOOLEAN_LOGIC_ALPHA.md, for boolean and, or, and not forms lowered through existing if semantics.

The earlier released exp-57 is defined in .llm/EXP_57_INTEGER_BITWISE_ALPHA.md, for explicit integer bitwise heads over same-width i32 and i64 operands plus source-authored std.math bitwise wrappers.

The earlier released exp-56 is defined in .llm/EXP_56_INTEGER_REMAINDER_ALPHA.md, for integer remainder % over same-width i32 and i64 operands plus source-authored std.math remainder/even/odd helpers.

The earlier released exp-55 is defined in .llm/EXP_55_RESULT_F64_BOOL_SOURCE_FLOW_ALPHA.md, for concrete f64 and bool result constructors and source match payload bindings.

The earlier released exp-54 is defined in .llm/EXP_54_STANDARD_CLI_TYPED_ARGUMENTS_ALPHA.md, for typed argument parse helpers in the staged CLI facade module.

The earlier released exp-53 is defined in .llm/EXP_53_STANDARD_CLI_SOURCE_FACADE_ALPHA.md, for explicit project-mode source search of the staged CLI facade module.

The earlier released exp-52 is defined in .llm/EXP_52_STANDARD_PROCESS_FACADE_SOURCE_SEARCH_ALPHA.md, for explicit project-mode source search of the staged process facade module.

The earlier released exp-51 is defined in .llm/EXP_51_STANDARD_LIBRARY_PATH_LIST_ALPHA.md, for ordered SLOVO_STD_PATH discovery of explicit standard-library source imports.

The earlier released exp-50 is defined in .llm/EXP_50_INSTALLED_STANDARD_LIBRARY_DISCOVERY_ALPHA.md, for installed toolchain discovery of explicit standard-library source imports.

The earlier released exp-49 is defined in .llm/EXP_49_STANDARD_IO_FACADE_SOURCE_SEARCH_ALPHA.md, for explicit project-mode source search of the staged IO facade module.

The earlier released exp-48 is defined in .llm/EXP_48_STANDARD_CORE_FACADE_SOURCE_SEARCH_ALPHA.md, for explicit project-mode source search of staged core facade modules.

The earlier released exp-47 is defined in .llm/EXP_47_STANDARD_HOST_FACADE_SOURCE_SEARCH_ALPHA.md, for explicit project-mode source search of staged host facade modules.

The earlier released exp-46 is defined in .llm/EXP_46_WORKSPACE_STANDARD_SOURCE_SEARCH_ALPHA.md, for explicit workspace-package standard source search.

The earlier released exp-45 is defined in .llm/EXP_45_STANDARD_RESULT_OPTION_SOURCE_SEARCH_ALPHA.md, for explicit project-mode std.result and std.option source search.

The earlier released exp-44 is defined in .llm/EXP_44_STANDARD_LIBRARY_SOURCE_SEARCH_ALPHA.md, for explicit project-mode std.math source search.

The earlier released exp-43 is defined in .llm/EXP_43_TECHNICAL_WHITEPAPERS_AND_SKILLS_ALPHA.md, for technical whitepapers, PDF publication artifacts, and beta language-design skills.

The earlier released exp-42 is defined in .llm/EXP_42_HOT_LOOP_BENCHMARK_MODE_ALPHA.md, for hot-loop benchmark mode alignment. It remains experimental maturity, not a beta claim, and does not change the exp-39 language surface.

The earlier released exp-41, Lisp Benchmark Comparison Alpha, is defined in .llm/EXP_41_LISP_BENCHMARK_COMPARISON_ALPHA.md for Lisp-family benchmark comparison alignment.

The earlier released exp-40, Benchmark Suite And License Alpha, is defined in .llm/EXP_40_BENCHMARK_SUITE_AND_LICENSE_ALPHA.md for benchmark-suite alignment, project licensing, and release naming criteria.

The earlier released exp-39, Standard Math Extensions And Benchmark Scaffold Alpha, is defined in .llm/EXP_39_STANDARD_MATH_EXTENSIONS_AND_BENCHMARK_SCAFFOLD_ALPHA.md for source-authored math helper extensions in std/math.slo and matching Glagol benchmark scaffold gates.

The earlier released exp-38, Standard Host Source Facades Alpha, is defined in .llm/EXP_38_STANDARD_HOST_SOURCE_FACADES_ALPHA.md and remains part of the experimental history.

The earlier released exp-37, Standard Time Source Facade Alpha, is defined in .llm/EXP_37_STANDARD_TIME_SOURCE_FACADE_ALPHA.md and remains part of the experimental history.

The earlier released exp-36, Standard Option Source Helpers Alpha, is defined in .llm/EXP_36_STANDARD_OPTION_SOURCE_HELPERS_ALPHA.md and remains part of the experimental history. The earlier released exp-35, Standard Result Bool Source Helpers Alpha, is defined in .llm/EXP_35_STANDARD_RESULT_BOOL_SOURCE_HELPERS_ALPHA.md and remains part of the experimental history.

The earlier released exp-34, String Parse Bool Result Alpha, is defined in .llm/EXP_34_STRING_PARSE_BOOL_RESULT_ALPHA.md and remains part of the experimental history.

The earlier released exp-33, Standard Result Source Helpers Alpha, is defined in .llm/EXP_33_STANDARD_RESULT_SOURCE_HELPERS_ALPHA.md and remains part of the experimental history.

The earlier released exp-32, Standard Math Source Helpers Alpha, is defined in .llm/EXP_32_STANDARD_MATH_SOURCE_HELPERS_ALPHA.md and remains part of the experimental history.

The earlier released exp-31, Checked F64 To I64 Result Alpha, is defined in .llm/EXP_31_CHECKED_F64_TO_I64_RESULT_ALPHA.md and remains part of the experimental history.

The earlier released exp-30, Standard Library Source Layout Alpha, is defined in .llm/EXP_30_STANDARD_LIBRARY_SOURCE_LAYOUT_ALPHA.md and remains part of the experimental history.

The earlier released exp-29, Numeric Struct Fields Alpha, is defined in .llm/EXP_29_NUMERIC_STRUCT_FIELDS_ALPHA.md and remains part of the experimental history.

The current released experimental alignment is exp-14, Standard Runtime Conformance Alignment, defined in .llm/EXP_14_STANDARD_RUNTIME_CONFORMANCE_ALIGNMENT.md. It adds no 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.

Release maturity policy lives in .llm/RELEASE_MATURITY_POLICY.md. All current releases are experimental maturity; beta is reserved for the general-purpose threshold.

Definition Of Supported

An example is compiler-supported only when Glagol can parse it, lower it, type-check it, emit LLVM for it, and the behavior is covered by an automated test.

Partial compiler recognition does not count as support. A checked form that can still reach a backend panic, lacks diagnostics, or lacks tests remains a design target.

Current supported subset:

examples/supported/add.slo
examples/supported/top-level-test.slo
examples/supported/local-variables.slo
examples/supported/composite-locals.slo
examples/supported/composite-struct-fields.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/array-struct-fields.slo
examples/supported/enum-payload-structs.slo
examples/supported/option-result.slo
examples/supported/option-result-flow.slo
examples/supported/option-result-payload.slo
examples/supported/option-result-match.slo
examples/supported/string-print.slo
examples/supported/string-value-flow.slo
examples/supported/print-bool.slo
examples/supported/standard-runtime.slo
examples/supported/unsafe.slo
examples/supported/time-sleep.slo
examples/supported/string-parse-i32-result.slo
examples/supported/result-helpers.slo
examples/supported/enum-payload-i32.slo
examples/supported/enum-payload-direct-scalars.slo
examples/supported/enum-struct-fields.slo
examples/supported/primitive-struct-fields.slo
examples/supported/f64-numeric-primitive.slo
examples/supported/i64-numeric-primitive.slo
examples/supported/numeric-widening-conversions.slo
examples/supported/checked-i64-to-i32-conversion.slo
examples/supported/integer-to-string.slo
examples/supported/string-parse-i64-result.slo
examples/supported/f64-to-string.slo
examples/supported/f64-to-i32-result.slo
examples/supported/string-parse-f64-result.slo
examples/supported/numeric-struct-fields.slo
examples/supported/f64-to-i64-result.slo
examples/supported/string-parse-bool-result.slo
(module name)
top-level (struct Name (field i32)...)
top-level (fn ...)
top-level (test "name" body... final-expression)
explicit i32 parameters and i32 returns, plus direct (option i32) and (result i32 i32) constructor returns
integer literals, parameter references, binary +, user function calls, legacy compiler/runtime compatibility alias print_i32, equality comparison =, ordering comparison <, and final-expression returns
local i32 bindings with let and var, local references after declaration, and 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 v1 struct value flow through immutable locals, parameters, returns, calls returning structs, and stored field access
fixed direct scalar array constructors over i32, i64, f64, and bool, immutable array locals, and literal checked indexing
fixed direct scalar array value flow through immutable array locals initialized from matching array-valued expressions, fixed array parameters, returns, calls returning arrays, and runtime-checked dynamic indexing
first-pass i32 option/result constructors as direct function returns
first v1 option/result value flow through immutable locals, parameters, calls returning option/result values, and is_some / is_none / is_ok / is_err tag observation
first v1 trap-based i32 option/result payload extraction with unwrap_some, unwrap_ok, and unwrap_err
v1.4 source-level match for existing (option i32) and (result i32 i32) values, with exhaustive arms, immutable arm-scoped payload bindings, one-or-more expression arm bodies, and common arm result types
exp-10 concrete (result string i32) with the same narrow result flow, observers, unwraps, and match shape used by existing (result i32 i32) support
exp-15 preferred result helper standard names std.result.is_ok, std.result.is_err, std.result.unwrap_ok, and std.result.unwrap_err for only (result i32 i32), (result i64 i32), and (result string i32), plus (result f64 i32) where promoted by exp-28, with legacy unqualified result helpers retained as compatibility syntax
exp-16 user-defined enum variants carrying exactly one i32 payload, qualified unary constructors, immutable arm-local payload bindings in exhaustive enum match, enum value flow through locals, parameters, returns, calls, tests, and main, and same-enum tag-plus-payload equality
exp-120 direct struct fields over fixed immutable arrays (array i32 N), (array i64 N), (array f64 N), (array bool N), and (array string N), with immutable struct flow and checked indexing after field access
exp-121 unary enum payload variants over current known non-recursive struct types, with one payload per payload variant, one payload type per enum when payload variants are present, immutable enum flow, and match payload binding exposing existing field access behavior
exp-118 fixed immutable arrays over string, with positive literal lengths, direct construction, immutable local value flow, parameters, returns, calls returning arrays, and checked indexing with i32 expressions only
exp-117 fixed immutable arrays over direct scalar element families i32, i64, f64, and bool, with positive literal lengths, direct construction, immutable local value flow, parameters, returns, calls returning arrays, and checked indexing with i32 expressions only
exp-116 user-defined enum variants carrying exactly one direct i64, f64, bool, or string payload in addition to the existing unary i32 lane, with the same one-binding exhaustive match shape, immutable value flow, and same-enum tag-plus-payload equality, while keeping one direct payload kind per enum when payload variants are present
exp-18 enum-typed struct fields using the current exp-4 payloadless and exp-16 unary i32 enum surfaces, with struct construction, immutable struct flow, field access, same-enum equality on field access, and enum match on field access
exp-19 primitive struct fields using direct bool and immutable string field types alongside direct i32 and exp-18 enum fields, with struct construction, immutable struct flow, field access, bool predicate use, string equality, and std.string.len
exp-112 immutable bool locals using direct immutable let locals declared as bool, initialized from already promoted bool expressions, and flowing into existing predicate, return, call, test, and main positions
exp-113 mutable scalar locals using direct mutable var locals declared as bool, i64, and f64, plus same-type set reassignment from already promoted scalar expressions
exp-114 mutable composite locals using same-type whole-value var / set reassignment for string, current concrete vec families, current concrete option/result families, current known struct values, and current enum values
exp-115 composite struct fields and nested structs using direct struct field declarations over current concrete vec families, current concrete option/result families, and current known non-recursive struct types, alongside the already supported direct scalar, immutable string, and current enum field families
exp-20 f64 numeric primitive using direct f64 parameters, returns, immutable locals, calls, decimal literals, same-type f64 arithmetic and comparison, and std.io.print_f64
exp-21 i64 numeric primitive using direct i64 parameters, returns, immutable locals, calls, explicit signed decimal i64 literal atoms, same-type i64 arithmetic and comparison, and std.io.print_i64
exp-22 numeric widening conversions using explicit std.num.i32_to_i64 : (i32) -> i64, std.num.i32_to_f64 : (i32) -> f64, and std.num.i64_to_f64 : (i64) -> f64 calls over the existing numeric primitives
exp-23 checked i64-to-i32 conversion using explicit std.num.i64_to_i32_result : (i64) -> (result i32 i32), returning ok for signed i32 range values and err 1 for out-of-range values
exp-24 integer to string formatting using explicit std.num.i32_to_string : (i32) -> string and std.num.i64_to_string : (i64) -> string, returning decimal signed ASCII text with - only for negative values and no leading +
exp-25 string parse i64 result using explicit std.string.parse_i64_result : (string) -> (result i64 i32), returning ok value for in-range ASCII signed decimal i64 text and err 1 for parse failure or out-of-range input
exp-26 f64 to string formatting using explicit std.num.f64_to_string : (f64) -> string, returning finite decimal ASCII text for promoted finite f64 values
exp-27 checked f64-to-i32 result conversion using explicit std.num.f64_to_i32_result : (f64) -> (result i32 i32), returning ok value only for finite, exactly integral inputs inside the signed i32 range and err 1 for non-finite, fractional, or out-of-range input
exp-28 string parse f64 result using explicit std.string.parse_f64_result : (string) -> (result f64 i32), returning ok value for complete finite ASCII decimal f64 text and err 1 for ordinary parse failure, non-finite text, trailing or leading unsupported characters, or out-of-domain input
exp-29 numeric struct fields using direct immutable i64 and finite f64 field types alongside already supported direct i32, bool, immutable string, and current enum fields, with constructors, immutable struct flow, field access, existing same-type numeric arithmetic/comparison, and existing numeric print/format helpers
exp-30 standard library source layout using std/ as the staged source home for standard library modules and examples, including narrow source-authored std/math.slo helpers and source wrappers over already promoted compiler-known calls, without automatic std imports or new compiler-known std.* names
exp-31 checked f64-to-i64 result conversion using explicit std.num.f64_to_i64_result : (f64) -> (result i64 i32), returning ok value only for finite, exactly integral inputs inside the signed i64 range and err 1 for non-finite, fractional, or out-of-range input
exp-32 standard math source helpers in staged std/math.slo, adding source-authored i64 and finite f64 abs, min, max, clamp, and square coverage without new compiler-known std.* runtime names
exp-39 standard math extension helpers in staged std/math.slo, adding source-authored neg, cube, zero/positive/negative predicates, and inclusive in_range coverage for i32, i64, and finite f64 without broad math or benchmark-performance claims
exp-33 standard result source helpers in staged std/result.slo, adding concrete is_err_* and unwrap_err_* wrappers for already promoted concrete result families plus unwrap_or_i32, unwrap_or_i64, unwrap_or_string, and unwrap_or_f64 without new compiler-known std.* runtime names
exp-34 string parse bool result using explicit std.string.parse_bool_result : (string) -> (result bool i32), returning ok true for exactly true, ok false for exactly false, and err 1 for empty input, uppercase/mixed-case text, leading/trailing whitespace, numeric text, or any other text
exp-35 standard result bool source helpers in staged std/result.slo, adding is_ok_bool, is_err_bool, unwrap_ok_bool, unwrap_err_bool, and unwrap_or_bool for (result bool i32) without new compiler-known std.* runtime names, generic result helpers, or stable ABI/layout claims
exp-36 standard option source helpers in staged std/option.slo, adding is_some_i32, is_none_i32, unwrap_some_i32, and unwrap_or_i32 for (option i32) without new compiler-known std.* runtime names, generic option helpers, automatic std imports/search, or stable ABI/layout claims
exp-37 standard time source facade in staged std/time.slo, adding monotonic_ms and sleep_ms_zero wrappers over the already released exp-8 time calls without new compiler-known std.* runtime names, automatic std imports/search, wall-clock/calendar/timezone APIs, high-resolution timers, async timers, cancellation, scheduling guarantees, or stable ABI/layout claims
first runtime string slice for immutable source string literals passed directly to legacy compiler/runtime compatibility alias print_string, which prints the string plus a newline and returns builtin unit
v1.2 immutable string value flow through let locals, parameters, returns, calls returning strings, string equality, string byte length through string_len, and top-level tests using string equality
legacy compiler/runtime compatibility alias print_bool, which prints true or false plus a newline and returns builtin unit
v1.5 standard-runtime alpha names std.io.print_i32, std.io.print_string, std.io.print_bool, and std.string.len, with legacy print_i32, print_string, print_bool, and string_len retained as compatibility aliases
exp-8 host time/sleep alpha names std.time.monotonic_ms: () -> i32 and std.time.sleep_ms: (i32) -> unit, with deterministic sleep_ms 0 and only structural/non-negative monotonic_ms checks in conformance fixtures
lexical unsafe expression blocks containing otherwise supported safe body forms, plus UnsafeRequired / UnsupportedUnsafeOperation diagnostics for raw unsafe operation heads reserved by v1.6: alloc, dealloc, load, store, ptr_add, unchecked_index, reinterpret, and ffi_call

Current exp-1 fixture support:

examples/supported/owned-string-concat.slo
examples/formatter/owned-string-concat.slo
compiler-known std.string.concat with signature (string, string) -> string, producing immutable runtime-owned strings

Current exp-2 fixture support:

examples/supported/vec-i32.slo
examples/formatter/vec-i32.slo
one concrete growable vector type (vec i32)
compiler-known std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, and std.vec.i32.index
vector equality with =

These are current compiler-supported exp-2 fixtures.

Current exp-3 fixture support:

examples/supported/host-io.slo
examples/formatter/host-io.slo
compiler-known std.io.eprint, std.process.argc, std.process.arg, std.env.get, std.fs.read_text, and std.fs.write_text
process argument out-of-range and file read failure as exact runtime traps
missing environment variables as empty strings
text file write status 0 on success and 1 on host failure

These are current compiler-supported exp-3 fixtures.

Current exp-8 release fixtures:

examples/supported/time-sleep.slo
examples/formatter/time-sleep.slo
compiler-known std.time.monotonic_ms: () -> i32
compiler-known std.time.sleep_ms: (i32) -> unit
non-negative host monotonic elapsed milliseconds with implementation-owned epoch
deterministic sleep_ms 0
no positive-duration timing assertion

These are current compiler-supported exp-8 fixtures aligned by the released exp-14 conformance release.

Current exp-12 release fixtures:

examples/supported/stdin-result.slo
examples/formatter/stdin-result.slo
compiler-known std.io.read_stdin_result: () -> (result string i32)
remaining stdin text as ok
ordinary EOF with no bytes as ok ""
ordinary host/input failure as err 1
deterministic-enough test-runner behavior through an implementation-owned fixed ok string

These are current compiler-supported exp-12 fixtures.

Current exp-13 release fixtures:

examples/supported/string-parse-i32-result.slo
examples/formatter/string-parse-i32-result.slo
compiler-known std.string.parse_i32_result: (string) -> (result i32 i32)
entire ASCII decimal signed i32 parsing with optional leading -
success as (ok i32 i32 value)
ordinary parse failure as (err i32 i32 1)
structural composition with std.io.read_stdin_result without assuming a particular stdin payload

These are current compiler-supported exp-13 fixtures.

Current exp-15 released fixtures:

examples/supported/result-helpers.slo
examples/formatter/result-helpers.slo
compiler-known std.result.is_ok and std.result.is_err for (result i32 i32) and (result string i32)
compiler-known std.result.unwrap_ok returning i32 for (result i32 i32) and string for (result string i32)
compiler-known std.result.unwrap_err returning i32 for both supported result families
legacy unqualified is_ok, is_err, unwrap_ok, and unwrap_err remain compatibility syntax where already supported

These are released Slovo-side exp-15 fixtures with matching Glagol gates.

Current exp-10 compiler-supported fixtures:

examples/supported/host-io-result.slo
examples/formatter/host-io-result.slo
concrete (result string i32) values
compiler-known std.process.arg_result, std.env.get_result, std.fs.read_text_result, and std.fs.write_text_result
ordinary host failure as err 1
exp-3 calls unchanged

Current exp-11 release fixtures:

examples/supported/random.slo
examples/formatter/random.slo
compiler-known std.random.i32: () -> i32
non-negative implementation-owned random i32 values for basic CLI use
exact unavailable trap: slovo runtime error: random i32 unavailable

Current exp-4 fixture support:

examples/supported/enum-basic.slo
examples/formatter/enum-basic.slo
payloadless (enum Name VariantA VariantB ...) declarations with at least one variant
zero-argument qualified constructors such as (Name.VariantA)
enum values through immutable locals, parameters, returns, calls, equality, and top-level tests
exhaustive payloadless enum match arms with common final result types

These are current compiler-supported exp-4 fixtures.

Current exp-16 fixture support:

examples/supported/enum-payload-i32.slo
examples/formatter/enum-payload-i32.slo
enum declarations mixing payloadless variants and unary i32 payload variants
zero-argument constructors for payloadless variants and qualified unary constructors for payload variants
enum values through immutable locals, parameters, returns, calls, equality, top-level tests, and main
exhaustive enum match arms with immutable arm-local payload bindings for payload variants
same-enum equality by tag for payloadless variants and by tag plus payload for payload variants

These are released experimental exp-16 fixtures.

Current exp-121 fixture support:

examples/supported/enum-payload-structs.slo
examples/formatter/enum-payload-structs.slo
unary enum payload variants over current known non-recursive struct types
one payload per payload variant and one payload type per enum when payload variants are present
qualified constructors, immutable enum locals, parameters, returns, calls, tests, and main
exhaustive match payload binding exposing the struct payload for existing field access and checked indexing through array-bearing struct fields

These are released experimental exp-121 fixtures.

Current exp-120 fixture support:

examples/supported/array-struct-fields.slo
examples/formatter/array-struct-fields.slo
direct struct field declarations over fixed immutable arrays with element families i32, i64, f64, bool, and string
struct construction from matching fixed-array expressions
immutable struct locals, parameters, returns, calls, tests, and main for structs carrying those field types
field access returning the declared fixed-array type for existing checked indexing with i32 expressions

These are released experimental exp-120 fixtures.

Current exp-118 fixture support:

examples/supported/array-string.slo
examples/formatter/array-string.slo
examples/supported/array-string-value-flow.slo
examples/formatter/array-string-value-flow.slo
fixed immutable arrays over string
positive literal lengths only, immutable arrays only, and checked indexing with i32 expressions only
direct constructors, immutable array locals, parameters, returns, calls returning arrays, top-level tests, and main

These are released experimental exp-118 fixtures.

Current exp-117 fixture support:

examples/supported/array-direct-scalars.slo
examples/formatter/array-direct-scalars.slo
examples/supported/array-direct-scalars-value-flow.slo
examples/formatter/array-direct-scalars-value-flow.slo
fixed immutable arrays over direct scalar element families i32, i64, f64, and bool
positive literal lengths only, immutable arrays only, and checked indexing with i32 expressions only
direct constructors, immutable array locals, parameters, returns, calls returning arrays, top-level tests, and main

These are released experimental exp-117 fixtures.

Current exp-116 fixture support:

examples/supported/enum-payload-direct-scalars.slo
examples/formatter/enum-payload-direct-scalars.slo
enum declarations mixing payloadless variants and unary direct i64, f64, bool, or string payload variants
one payload per payload variant, with one direct payload kind per enum when payload variants are present
zero-argument constructors for payloadless variants and qualified unary constructors for payload variants
enum values through immutable locals, parameters, returns, calls, equality, top-level tests, and main
exhaustive enum match arms with one immutable arm-local payload binding for payload variants

These are released experimental exp-116 fixtures.

Released exp-17 project contract fixture:

examples/projects/enum-imports/
export lists may include top-level enum names in project/workspace modules
import lists may import exported enum names
imported enum types may be used in function signatures, immutable locals, calls/returns, equality, exhaustive enum matches, and qualified constructors
the enum surface remains exactly exp-4 payloadless variants plus exp-16 unary i32 payload variants

This is a released experimental exp-17 fixture. It does not claim beta maturity or widen manifests, packages, enum payloads, generics, containers, mutation, printing, ordering, hashing, reflection, or stable ABI/layout.

Current exp-18 fixture support:

examples/supported/enum-struct-fields.slo
examples/formatter/enum-struct-fields.slo
direct struct fields whose types are current user-defined enum names
struct construction with payloadless and unary i32 enum field values
immutable struct locals, parameters, returns, calls, tests, and main
field access returning enum values
same-enum equality and exhaustive enum match on field access

This is a released experimental exp-18 fixture. It does not claim beta maturity or widen enum payloads, containers, nested structs, mutation, printing, ordering, hashing, reflection, import behavior, manifest schema, package-manager behavior, or stable ABI/layout.

Current exp-19 fixture support:

examples/supported/primitive-struct-fields.slo
examples/formatter/primitive-struct-fields.slo
direct struct fields whose types are i32, bool, or immutable string
struct construction with i32, bool, and immutable string field values
immutable struct locals, parameters, returns, calls, tests, and main
field access returning primitive values
bool field access in predicate/test positions
string field equality and std.string.len on field access

This is a released experimental exp-19 fixture. It does not claim beta maturity or widen arrays, vectors, options, results, nested structs, mutation, string ownership/cleanup guarantees, broader string operations, printing, package/import behavior, manifest schema, generics, methods, traits, or stable ABI/layout.

Current exp-115 fixture support:

examples/supported/composite-struct-fields.slo
examples/formatter/composite-struct-fields.slo
direct struct field declarations using current concrete vec families
direct struct field declarations using current concrete option/result families
direct struct field declarations using current known non-recursive struct types
coexistence with the already supported direct i32, bool, immutable string, i64, finite f64, and current enum field families
immutable struct locals, parameters, returns, calls, tests, and main for structs carrying those fields
field access returning those composite field values for use with existing vec indexing, option/result match, string/number helpers, enum match, and nested struct helper flow

This is a released experimental exp-115 fixture alignment. It does not claim beta maturity or add arrays as struct fields, field mutation, recursive/cyclic layouts, imports, runtime names, or stable ABI/layout.

Current exp-114 fixture support:

examples/supported/composite-locals.slo
examples/formatter/composite-locals.slo
same-type mutable whole-value var / set reassignment for string, current concrete vec families, current concrete option/result families, current known struct values, and current enum values
fixed arrays remain immutable and field/element/payload mutation stays out of scope

This is a released experimental exp-114 fixture alignment. It does not claim beta maturity or add mutable arrays, field mutation, vector element mutation, option/result payload mutation, enum payload mutation, imports, runtime names, or stable ABI/layout.

Current exp-113 fixture support:

examples/supported/local-variables.slo
examples/formatter/local-variables.slo
direct mutable var locals declared as bool, i64, and f64
same-type set reassignment from already promoted scalar expressions for those declared local types
the fixture pair retains the earlier direct i32 local flow and exp-112 immutable bool local coverage

This is a released experimental exp-113 fixture alignment. It does not claim beta maturity or add mutable string locals, vector mutation, option/result mutation, struct or enum mutation, mixed-type assignment, imports, runtime names, or stable ABI/layout.

Current exp-20 fixture support:

examples/supported/f64-numeric-primitive.slo
examples/formatter/f64-numeric-primitive.slo
direct f64 function parameters and returns
immutable let locals declared as f64
calls passing and returning f64
decimal f64 literals in f64 contexts
same-type f64 +, -, *, /, =, <, >, <=, and >=
std.io.print_f64
top-level tests and main returning i32

This is a released experimental exp-20 fixture. It does not claim beta maturity or widen f32, wider/common integer types, char/bytes/decimal, numeric casts, mixed numeric arithmetic, f64 collections, f64 enum payloads, f64 struct fields, parsing, random floats, broader math APIs, manifest schema, or stable ABI/layout.

Current exp-21 fixture support:

examples/supported/i64-numeric-primitive.slo
examples/formatter/i64-numeric-primitive.slo
direct i64 function parameters and returns
immutable let locals declared as i64
calls passing and returning i64
explicit signed decimal i64 literal atoms with the i64 suffix
same-type i64 +, -, *, /, =, <, >, <=, and >=
std.io.print_i64
top-level tests and main returning i32

This is a released experimental exp-21 fixture. It does not claim beta maturity or widen f32, unsigned integers, narrower integer widths, char/bytes/decimal, numeric casts, implicit promotion, mixed i32/i64/f64 arithmetic, i64 collections, i64 enum payloads, i64 struct fields, parsing, random i64, broader math APIs, manifest schema, or stable ABI/layout.

Current exp-22 fixture support:

examples/supported/numeric-widening-conversions.slo
examples/formatter/numeric-widening-conversions.slo
std.num.i32_to_i64 : (i32) -> i64
std.num.i32_to_f64 : (i32) -> f64
std.num.i64_to_f64 : (i64) -> f64
converted values feeding same-type arithmetic and comparison
top-level tests and main returning i32

This is a released experimental alpha exp-22 fixture. It does not claim beta maturity or add implicit promotion, mixed numeric operators, narrowing or checked conversions, cast syntax, f32, unsigned or narrower integer families, numeric parse/format APIs, stable ABI/layout, manifest schema, or standard-library breadth.

Current exp-23 fixture support:

examples/supported/checked-i64-to-i32-conversion.slo
examples/formatter/checked-i64-to-i32-conversion.slo
std.num.i64_to_i32_result : (i64) -> (result i32 i32)
ok results for signed i32 range values
err 1 results for out-of-range values, without range-failure traps
existing std.result.* observers and unwraps
top-level tests and main returning i32

This is a released experimental alpha exp-23 fixture. It does not claim beta maturity or add f64 narrowing, checked cast generics, mixed numeric operators, std.num.cast, unsigned or narrower integer families, numeric parse/format APIs, stable ABI/layout, manifest schema, or standard-library breadth.

Current exp-25 fixture support:

examples/supported/string-parse-i64-result.slo
examples/formatter/string-parse-i64-result.slo
std.string.parse_i64_result : (string) -> (result i64 i32)
complete non-empty ASCII signed decimal i64 parsing with optional leading -
success as ok value and parse/range failure as err 1
existing result observation/extraction helpers over (result i64 i32)
top-level tests and main returning i32

This is a released experimental alpha exp-25 fixture. It does not claim beta maturity or add f64 parse, generic parse, leading +, whitespace trimming, underscores, base/radix prefixes, locale-aware parsing, Unicode digit parsing, rich parse errors, stable ABI/layout/ownership, manifest schema, or standard-library breadth.

Current exp-26 fixture support:

examples/supported/f64-to-string.slo
examples/formatter/f64-to-string.slo
std.num.f64_to_string : (f64) -> string
finite decimal ASCII text for promoted finite f64 values
existing string equality, std.string.len, and std.io.print_string
top-level tests and main returning i32

This is a released experimental alpha exp-26 fixture. It does not claim beta maturity or add f32, f64 parse, generic format/display/interpolation, locale/base/radix/grouping/padding/precision controls, stable NaN/infinity text, implicit conversion, stable ABI/layout/ownership, manifest schema, or standard-library breadth.

Current exp-27 fixture support:

examples/supported/f64-to-i32-result.slo
examples/formatter/f64-to-i32-result.slo
std.num.f64_to_i32_result : (f64) -> (result i32 i32)
ok value only for finite, exactly integral f64 inputs inside the signed i32 range
err 1 for non-finite, fractional, or out-of-range input
existing result observation/extraction helpers over (result i32 i32)
top-level tests and main returning i32

This is a released experimental alpha exp-27 fixture. It does not claim beta maturity or add unchecked f64 to i32, casts or cast syntax, generic cast_checked, f32, unsigned or narrower integer families, f64 parse, mixed numeric arithmetic, numeric containers, stable ABI/layout/ownership, manifest schema, or standard-library breadth.

Current exp-28 fixture support:

examples/supported/string-parse-f64-result.slo
examples/formatter/string-parse-f64-result.slo
std.string.parse_f64_result : (string) -> (result f64 i32)
complete finite ASCII decimal f64 parsing
ok value for 12.5 and -0.25
err 1 for ordinary parse failure, non-finite text, trailing or leading unsupported characters, or out-of-domain input
existing result observation/extraction helpers over (result f64 i32)
top-level tests and main returning i32

This is a released experimental alpha exp-28 fixture. It does not claim beta maturity or 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, or standard-library breadth.

Current exp-29 fixture support:

examples/supported/numeric-struct-fields.slo
examples/formatter/numeric-struct-fields.slo
direct immutable struct fields whose field types are exactly i64 or f64
constructors with i64 and finite f64 field initializers
immutable struct local/parameter/return/call flow
field access returning i64 or f64
existing same-type numeric arithmetic/comparison after field access
existing numeric print/format helpers after field access
top-level tests and main returning i32

This is a released experimental alpha exp-29 fixture. It does not claim beta maturity or 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, FFI layout claims, or standard-library breadth.

Current exp-30 source-layout support:

std/README.md
std/cli.slo
std/io.slo
std/string.slo
std/num.slo
std/result.slo
std/math.slo
examples/formatter/std-source-layout-alpha.slo
flat current module names inside std/*.slo while repo-root std import/search remains deferred
source-authored std/math.slo helpers: abs_i32, min_i32, max_i32, clamp_i32, square_i32, and square_f64

This is a released experimental alpha exp-30 source-layout fixture. It does not claim beta maturity or add automatic standard-library imports, replacement of compiler-known std.* calls, new compiler-known std.* operation names, stable standard-library APIs, manifest schema changes, broad math, generics, traits, overloads, module/package registry behavior, or stable ABI/layout.

Current exp-31 fixture support:

examples/supported/f64-to-i64-result.slo
examples/formatter/f64-to-i64-result.slo
std.num.f64_to_i64_result : (f64) -> (result i64 i32)
ok value only for finite, exactly integral f64 inputs inside the signed i64 range
err 1 for non-finite, fractional, or out-of-range input
formatter-stable conservative out-of-range fixture value 9223372036854776000.0
existing result observation/extraction helpers over (result i64 i32)
std.num.i64_to_string over a successful i64 payload
top-level tests and main returning i32

This is a released experimental alpha exp-31 fixture. It does not claim beta maturity or add unchecked casts, unchecked f64 to i64, cast syntax, generic cast_checked, f32, unsigned or narrower integer families, mixed numeric arithmetic, broad math, numeric containers, stable ABI/layout/ ownership, manifest schema changes, or standard-library breadth. Detailed edge behavior around the f64/i64 limits is implementation-owned Glagol test coverage.

Current exp-32 source-helper support:

std/math.slo
retained exp-30 helpers: abs_i32, min_i32, max_i32, clamp_i32, square_i32, and square_f64
added i64 helpers: abs_i64, min_i64, max_i64, clamp_i64, and square_i64
added finite f64 helpers: abs_f64, min_f64, max_f64, and clamp_f64
ordinary source functions using existing same-type arithmetic/comparison, if, literals, calls, and explicit signatures

This is a released experimental alpha exp-32 source fixture. It does not claim beta maturity or add automatic standard-library imports, compiler-loaded std/ source, new compiler-known std.* operation names, broad math, trigonometry, sqrt, pow, f32, unsigned or narrower integer families, generic math, overloads, traits, mixed numeric arithmetic, numeric containers, stable ABI/layout/ownership, manifest schema changes, or standard-library breadth.

Current exp-33 source-helper support:

std/result.slo
retained i32 helpers: is_ok_i32, is_err_i32, unwrap_ok_i32, and unwrap_err_i32
completed concrete err wrappers: is_err_i64, unwrap_err_i64, is_err_string, unwrap_err_string, is_err_f64, and unwrap_err_f64
concrete fallback helpers: unwrap_or_i32, unwrap_or_i64, unwrap_or_string, and unwrap_or_f64
ordinary source functions over existing std.result.is_ok, std.result.is_err, std.result.unwrap_ok, std.result.unwrap_err, if, match, parameters, and explicit signatures

This is a released experimental alpha exp-33 source fixture. It does not claim beta maturity or add automatic standard-library imports, compiler-loaded std/ source, new compiler-known std.* operation names, generic std.result.map, generic std.result.unwrap_or, std.result.and_then, option helper names, new result payload families, stable ABI/layout/ ownership, manifest schema changes, or standard-library breadth.

Current exp-34 fixture support:

examples/supported/string-parse-bool-result.slo
examples/formatter/string-parse-bool-result.slo
std.string.parse_bool_result : (string) -> (result bool i32)
exact complete ASCII lowercase true and false parsing
ok true for true
ok false for false
err 1 for empty input, uppercase or mixed-case text, leading or trailing whitespace, numeric text, and any other text
existing result observation/extraction helpers over the returned (result bool i32) value
top-level tests and main returning i32

This is a released experimental alpha exp-34 fixture. It does not claim beta maturity or add generic parse APIs, trap-based parse, bool parsing beyond exact lowercase true/false, string/bytes parse, whitespace trimming, case-insensitive parsing, locale/Unicode parsing, numeric boolean parsing, rich parse errors, source-authored std/result.slo bool wrappers, stable helper ABI/layout/ownership, manifest schema changes, or standard-library breadth.

Current exp-35 source-helper support:

std/result.slo
retained exp-33 concrete result source helpers
added (result bool i32) helpers: is_ok_bool, is_err_bool, unwrap_ok_bool, unwrap_err_bool, and unwrap_or_bool
ordinary source functions over existing compiler-supported std.result.is_ok, std.result.is_err, std.result.unwrap_ok, std.result.unwrap_err, if, parameters, and explicit signatures
alignment with exp-34 compiler-supported bool parse result fixture flow

This is a released experimental alpha exp-35 source fixture. It does not claim beta maturity or add automatic standard-library imports, compiler-loaded std/ source, new compiler-known std.* operation names, source-authored generic result helpers, generic std.result.map, generic std.result.unwrap_or, std.result.and_then, option helper names, source constructors for (result bool i32), general source match over (result bool i32) beyond compiler-supported fixture flow, stable ABI/layout/ownership, manifest schema changes, or standard-library breadth.

Current exp-74/exp-109 source-helper support:

std/result.slo
retained exp-33 and exp-35 concrete result source helpers
concrete source constructors: ok_i32, err_i32, ok_i64, err_i64, ok_string, err_string, ok_f64, err_f64, ok_bool, and err_bool
concrete bridge helpers: ok_or_none_i32, ok_or_none_i64, ok_or_none_string, ok_or_none_f64, and ok_or_none_bool
ordinary source functions over existing compiler-supported ok, err, std.result.is_ok, std.result.unwrap_ok, some, none, if, match, parameters, and explicit signatures

This is the released experimental alpha result helper family through exp-109. It does not claim beta maturity or add automatic standard-library imports, compiler-loaded std/ source, new compiler-known std.* operation names, generic result helpers, broader map/and_then/transpose/flatten packages, new payload families, stable ABI/layout/ownership, manifest schema changes, or standard-library breadth.

Current exp-36/exp-75/exp-95/exp-100/exp-102/exp-109 source-helper support:

std/option.slo
concrete (option i32) helpers: some_i32, none_i32, is_some_i32, is_none_i32, unwrap_some_i32, unwrap_or_i32, and some_or_err_i32
concrete (option i64) helpers: some_i64, none_i64, is_some_i64, is_none_i64, unwrap_some_i64, unwrap_or_i64, and some_or_err_i64
concrete (option f64) helpers: some_f64, none_f64, is_some_f64, is_none_f64, unwrap_some_f64, unwrap_or_f64, and some_or_err_f64
concrete (option bool) helpers: some_bool, none_bool, is_some_bool, is_none_bool, unwrap_some_bool, unwrap_or_bool, and some_or_err_bool
concrete (option string) helpers: some_string, none_string, is_some_string, is_none_string, unwrap_some_string, unwrap_or_string, and some_or_err_string
ordinary source functions over existing compiler-supported is_some, is_none, unwrap_some, ok, err, if, parameters, and explicit signatures
flat std/*.slo facade organization, with any future std.slo aggregator/reexport layer deferred until import/search semantics exist

This is the released experimental alpha option helper family through exp-109. It does not claim beta maturity or add automatic standard-library imports, repo-root std/ search, compiler-loaded std/ source, new compiler-known std.* operation names, generic option helpers, option payload families beyond (option i32), (option i64), (option f64), (option bool), and (option string), stable ABI/layout/ownership, manifest schema changes, or standard-library breadth.

Current exp-111 stdlib/source support:

std/io.slo retains the zero-returning and value-returning print wrappers and now also adds 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, and read_stdin_bool_or
the matching explicit import fixture examples/projects/std-import-io/ now imports the expanded helper list and keeps stdin assertions structural so the runner does not need to provide a specific stdin payload
all new helpers are ordinary source wrappers over the promoted std.io.read_stdin_result, std.string.parse_*_result, and exp-109 std.result.ok_or_none_*

Current exp-110 stdlib/source support:

std/string.slo retains len, concat, the concrete parse_*_result wrappers, the zero/custom-fallback helpers, and now also adds parse_i32_option, parse_i64_option, parse_f64_option, and parse_bool_option
std/env.slo retains get, get_result, has, get_or, the typed *_result and fallback helpers, and now also adds get_option, get_i32_option, get_i64_option, get_f64_option, and get_bool_option
std/fs.slo retains text read/write helpers, the typed *_result and fallback helpers, and now also adds read_text_option, read_i32_option, read_i64_option, read_f64_option, and read_bool_option
std/process.slo retains argc, arg, arg_result, has_arg, arg_or, arg_or_empty, the typed *_result and fallback helpers, and now also adds arg_option, arg_i32_option, arg_i64_option, arg_f64_option, and arg_bool_option
std/cli.slo retains arg_text_result, the typed *_result and fallback helpers, and now also adds arg_text_option, arg_i32_option, arg_i64_option, arg_f64_option, and arg_bool_option
all new helpers are ordinary source wrappers over existing concrete result helpers through exp-109 std.result.ok_or_none_*
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 import the expanded helper lists and keep deterministic option/result and fallback coverage

This is the current released exp-111 stdlib/source contract summary, with the immediately previous exp-110 source package still listed above. It does not claim beta maturity or add compiler-known std names, generics, new runtime calls beyond the already promoted stdin-result lane, line/binary/async stdin APIs, vec work, stable ABI/layout/ownership, or optimizer guarantees.

Current exp-125 Slovo-side target:

std/result.slo stages concrete (result u32 i32) and (result u64 i32) constructor, observer, unwrap, fallback, and option-bridge helpers
std/option.slo stages concrete (option u32) and (option u64) constructor, observer, unwrap, fallback, and result-bridge helpers
std/string.slo stages parse_u32_* and parse_u64_* result/option/ fallback helper lanes
std/num.slo stages u32_to_string and u64_to_string
std/io.slo, std/env.slo, std/fs.slo, std/process.slo, and std/cli.slo stage matching u32/u64 helper parity over the concrete family pattern already used for i32, i64, f64, bool, and string
the matching Slovo fixtures are u32-numeric-primitive.slo, u64-numeric-primitive.slo, unsigned-integer-to-string.slo, string-parse-u32-result.slo, string-parse-u64-result.slo, and the widened examples/projects/std-import-* module fixtures

This is a current Slovo-side contract target only. It does not claim beta maturity, released compiler support, implicit promotion, mixed signed/unsigned arithmetic, broader cast families, unsigned widths beyond u32/u64, or stable ABI/layout/ownership.

Current exp-37 source-facade support:

std/time.slo
narrow time wrappers: monotonic_ms and sleep_ms_zero
ordinary source functions over existing compiler-supported std.time.monotonic_ms, std.time.sleep_ms, parameters, sequential body forms, and explicit signatures
flat std/*.slo facade organization, with any future std.slo aggregator/reexport layer deferred until import/search semantics exist

This is a released experimental alpha exp-37 source fixture. It does not claim beta maturity or add automatic standard-library imports, repo-root std/ search, compiler-loaded std/ source, new compiler-known std.* operation names, wall-clock/calendar/timezone APIs, high-resolution timers, async timers, cancellation, scheduling guarantees, stable ABI/layout/ownership, manifest schema changes, or standard-library breadth.

Current exp-38 source-facade support:

std/random.slo
std/env.slo
std/fs.slo
narrow host/runtime wrappers for std.random.i32, std.env.get, std.env.get_result, std.fs.read_text, std.fs.read_text_result, std.fs.write_text, and std.fs.write_text_result
flat std/*.slo facade organization, with any future std.slo aggregator/reexport layer deferred until import/search semantics exist

This is a released experimental alpha exp-38 source fixture. It does not claim beta maturity or add automatic standard-library imports, repo-root std/ search, compiler-loaded std/ source, new compiler-known std.* operation names, random seed/range/bytes/float/UUID/crypto APIs, environment mutation/enumeration, rich host error ADTs, binary/directory/streaming/async filesystem APIs, stable ABI/layout/ownership, manifest schema changes, or standard-library breadth.

Current exp-39 source-helper support:

std/math.slo
retained exp-32 helpers: abs, min, max, clamp, and square for the currently staged i32, i64, and finite f64 families
added helpers for each family: neg, cube, is_zero, is_positive, is_negative, and inclusive in_range
ordinary source functions using existing same-type arithmetic/comparison, if, literals, calls, and explicit signatures
matching Glagol benchmark scaffold gates for local math-loop timing comparisons only, with no performance threshold in the language contract

This is a released experimental alpha exp-39 source fixture. It does not claim beta maturity or add automatic standard-library imports, repo-root std/ search, compiler-loaded std/ 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 ABI/layout/ownership, manifest schema changes, or standard-library breadth.

Current exp-40 governance/tooling support:

project licensing recorded as MIT OR Apache-2.0
release naming criteria documented in .llm/ALPHA_BETA_RELEASE_CRITERIA.md
Glagol benchmark-suite gates aligned for math-loop, branch-loop, parse-loop, array-index-loop, string-eq-loop, array-struct-field-loop, and enum-struct-payload-loop
Slovo, C, Rust, Python, and Clojure benchmark source slots, with local-only timing comparisons and no release threshold; Common Lisp/SBCL is also part of the current paired benchmark publication surface

This is a released experimental alpha exp-40 governance/tooling fixture. It does not claim beta maturity or add source syntax, type forms, standard-library APIs, optimizer guarantees, benchmark thresholds, cross-machine performance claims, stable ABI/layout/ownership, package registry behavior, or language-surface changes.

Current exp-41 governance/tooling support:

Glagol benchmark-suite gates include Common Lisp/SBCL beside Clojure as a second Lisp-family comparison target
benchmark timing is explicitly cold-process local-machine evidence only
Clojure timings include JVM and Clojure startup; Common Lisp timings include SBCL script startup
the current published benchmark-suite kernel inventory is math-loop, branch-loop, parse-loop, array-index-loop, string-eq-loop, array-struct-field-loop, and enum-struct-payload-loop

This is a released experimental alpha exp-41 governance/tooling fixture. It does not claim beta maturity or add source syntax, type forms, standard-library APIs, optimizer guarantees, benchmark thresholds, cross-machine performance claims, stable ABI/layout/ownership, package registry behavior, or language-surface changes.

Current exp-42 governance/tooling support:

Glagol benchmark-suite gates separate cold-process and hot-loop timing modes
hot-loop mode uses a larger runtime-supplied loop count and reports total time plus normalized median time for the base loop count
the paired benchmark-suite kernel inventory now covers arithmetic, branching, parsing, checked fixed-array indexing, exact string equality, direct fixed-array struct-field access, and unary enum payload matching over non-recursive struct payloads
Slovo language surface remains unchanged; no high-resolution timing API is promoted

This is a released experimental alpha exp-42 governance/tooling fixture. It does not claim beta maturity or add source syntax, type forms, standard-library APIs, high-resolution timing APIs, optimizer guarantees, benchmark thresholds, cross-machine performance claims, stable ABI/layout/ownership, package registry behavior, or language-surface changes.

Current exp-43 documentation/tooling support:

docs/SLOVO_WHITEPAPER.md records the current language state, Lisp-family comparison, local benchmark evidence, and path to 1.0.0-beta
generated PDF artifacts publish the whitepaper and language manifest
.llm/skills/slovo-beta-language-design/SKILL.md records the manifest-first beta language-design workflow

This is a released experimental alpha exp-43 documentation/tooling fixture. It does not claim beta maturity or add source syntax, type forms, standard-library APIs, optimizer guarantees, benchmark thresholds, cross-machine performance claims, stable ABI/layout/ownership, package registry behavior, or language-surface changes.

Current exp-44 language/tooling support:

std/math.slo carries its own export list for helper imports
examples/projects/std-import-math/ imports (import std.math (...)) without a local copied math.slo
Glagol resolves explicit project-mode std.math imports to the repo-root standard-library source file

This is a released experimental alpha exp-44 source-search fixture. It does not claim beta maturity or add automatic standard-library imports, broad standard-library APIs, package registry behavior, workspace/package std imports, optimizer guarantees, stable ABI/layout/ownership, or a std.slo aggregator.

Current exp-45 language/tooling support:

std/result.slo and std/option.slo carry their own export lists
examples/projects/std-import-result/ imports (import std.result (...)) without a local copied result.slo
examples/projects/std-import-option/ imports (import std.option (...)) without a local copied option.slo
Glagol resolves these explicit project-mode imports to the repo-root standard-library source files

This is a released experimental alpha exp-45 source-search fixture. It does not claim beta maturity or add automatic standard-library imports, generic result or option helpers, broad standard-library APIs, package registry behavior, workspace/package std imports, optimizer guarantees, stable ABI/layout/ownership, or a std.slo aggregator.

Current exp-46 language/tooling support:

examples/workspaces/std-import-option/ imports (import std.option (...)) from a workspace package without a local copied option.slo
Glagol resolves explicit workspace-package std.<module> imports to the repo-root standard-library source files

This is a released experimental alpha exp-46 source-search fixture. It does not claim beta maturity or add automatic standard-library imports, workspace dependency syntax for std, package registry behavior, installed toolchain stdlib paths, generic option helpers, broad standard-library APIs, optimizer guarantees, stable ABI/layout/ownership, or a std.slo aggregator.

Current exp-47 language/tooling support:

std/time.slo, std/random.slo, std/env.slo, and std/fs.slo carry their own export lists for helper imports
examples/projects/std-import-time/ imports (import std.time (...)) without a local copied time.slo
examples/projects/std-import-random/ imports (import std.random (...)) without a local copied random.slo
examples/projects/std-import-env/ imports (import std.env (...)) without a local copied env.slo
examples/projects/std-import-fs/ imports (import std.fs (...)) without a local copied fs.slo

This is a released experimental alpha exp-47 source-search fixture. It does not claim beta maturity or add automatic standard-library imports, installed toolchain stdlib paths, broad host APIs, optimizer guarantees, stable ABI/layout/ownership, package registry behavior, or a std.slo aggregator.

Current exp-48 language/tooling support:

std/string.slo and std/num.slo carry their own export lists for helper imports
examples/projects/std-import-string/ imports (import std.string (...)) without a local copied string.slo
examples/projects/std-import-num/ imports (import std.num (...)) without a local copied num.slo

This is a released experimental alpha exp-48 source-search fixture. It does not claim beta maturity or add automatic standard-library imports, installed toolchain stdlib paths, generic parse/format APIs, broad numeric casts, optimizer guarantees, stable ABI/layout/ownership, package registry behavior, or a std.slo aggregator.

Current exp-49 language/tooling support:

std/io.slo carries its own export list for helper imports
examples/projects/std-import-io/ imports (import std.io (...)) without a local copied io.slo

This is a released experimental alpha exp-49 source-search fixture. It does not claim beta maturity or add automatic standard-library imports, installed toolchain stdlib paths, broad IO APIs, formatted output APIs, optimizer guarantees, stable ABI/layout/ownership, package registry behavior, or a std.slo aggregator.

Current exp-50 language/tooling support:

explicit standard-source imports may discover staged std/*.slo modules from installed share/slovo/std toolchain layouts
no new std/*.slo module, helper, or compiler-known runtime name is added

This is a released experimental alpha exp-50 discovery fixture. It does not claim beta maturity or add automatic standard-library imports, package registry behavior, lockfiles, package std dependencies, stable install layout guarantees, optimizer guarantees, stable ABI/layout/ownership, or a std.slo aggregator.

Current exp-51 language/tooling support:

SLOVO_STD_PATH may name an ordered OS path list of standard-library roots
the first root containing the requested module file wins

This is a released experimental alpha exp-51 discovery fixture. It does not claim beta maturity or add automatic standard-library imports, package registry behavior, lockfiles, semantic version solving, stable package manager behavior, optimizer guarantees, stable ABI/layout/ownership, or a std.slo aggregator.

Current exp-52 language/tooling support:

std/process.slo carries its own export list for helper imports
examples/projects/std-import-process/ imports (import std.process (...)) without a local copied process.slo

This is a released experimental alpha exp-52 source-search fixture. It does not claim beta maturity or add automatic standard-library imports, package registry behavior, process spawning, exit/status control, current-directory APIs, signal handling, optimizer guarantees, stable ABI/layout/ownership, or a std.slo aggregator.

Current exp-53 language/tooling support:

std/cli.slo carries its own export list for helper imports
std/cli.slo imports std.process and std.string as ordinary standard source modules
examples/projects/std-import-cli/ imports (import std.cli (...)) without a local copied cli.slo

This is a released experimental alpha exp-53 source-search fixture. It does not claim beta maturity or add automatic standard-library imports, package registry behavior, shell parsing, option/flag parsing, subcommands, environment-backed configuration, optimizer guarantees, stable ABI/layout/ownership, or a std.slo aggregator.

Current exp-54 language/tooling support:

std/cli.slo adds arg_i64_result and arg_i64_or_zero
std/cli.slo adds arg_f64_result, arg_f64_or_zero, arg_bool_result, and arg_bool_or_false
examples/projects/std-import-cli/ imports the expanded helper list and keeps deterministic tests on the currently source-supported result families

This is a released experimental alpha exp-54 source-facade fixture. It does not claim beta maturity or add automatic standard-library imports, package registry behavior, shell parsing, option/flag parsing, subcommands, environment-backed configuration, optimizer guarantees, stable ABI/layout/ownership, or a std.slo aggregator.

Current exp-101 stdlib/source support:

std/vec_string.slo now stages the concrete (vec string) facade through the exp-99 baseline plus the exp-101 option-query and transform package
the baseline direct wrappers remain empty, append, len, and at
the baseline builder helpers remain singleton, append2, append3, pair, and triple
the baseline query helpers remain is_empty, index_or, first_or, and last_or
the new option-query helpers are index_option, first_option, last_option, index_of_option, and last_index_of_option
the new transform helpers are concat, take, drop, reverse, and subvec
the simple real-program helpers remain contains and count_of
the helper lane stays source-authored, recursive, and immutable over only std.vec.string.empty, std.vec.string.append, std.vec.string.len, and std.vec.string.index
the explicit project fixture examples/projects/std-import-vec_string/ now exercises deterministic baseline, option-query, transform, subvec, and real-program coverage

This is the current released exp-101 stdlib/source contract. It does not claim beta maturity or add compiler-known std names, generics, vec edit helpers, prefix/suffix helpers, nested vecs, mutating/capacity APIs, stable ABI/layout/ownership, or optimizer guarantees.

Current exp-108 stdlib/source support:

std/vec_string.slo retains the exp-99 baseline and exp-101 option-query plus transform surfaces, exp-107 edit helpers, and now also ships starts_with, without_prefix, ends_with, and without_suffix
std/vec_f64.slo retains the exp-103 baseline, exp-105 transform, and exp-106 option-query surfaces, exp-107 edit helpers, and now also ships the same four prefix/suffix helpers
std/vec_bool.slo retains the exp-104 baseline, exp-105 transform, and exp-106 option-query surfaces, exp-107 edit helpers, and now also ships the same four prefix/suffix helpers
all three helper lanes stay source-authored, recursive, and immutable over only their existing four runtime calls per family plus already promoted concrete option families where earlier helpers need them
the explicit project fixtures examples/projects/std-import-vec_string/, examples/projects/std-import-vec_f64/, and examples/projects/std-import-vec_bool/ now freeze deterministic direct, builder, query, option-query, prefix/suffix, transform, subvec, edit, and real-program coverage

This is the current released exp-108 stdlib/source contract. It does not claim beta maturity or add compiler-known std names, generics, sorting, mapping, filtering, nested vecs, mutating/capacity APIs, stable ABI/layout/ownership, or optimizer guarantees.

Current exp-93 stdlib/source support:

std/vec_i32.slo retains the exp-76 direct, builder, query, option-query, simple real-program, transform, generated constructor, range, replace, remove, insert, subvec, remove-range, replace-range, insert-range, starts-with, ends-with, without-suffix, and without-prefix helper surface
std/vec_i32.slo adds exactly one new public helper, count_of
count_of ((values (vec i32)) (target i32)) -> i32 returns the number of elements in values equal to target
count_of (empty) target returns 0
if no element equals target, count_of returns 0
repeated matches are counted exactly
the helper leaves both source vectors unchanged
the implementation is an ordinary source helper over existing len, at, equality, and while
examples/projects/std-import-vec_i32/ imports the expanded helper list and keeps deterministic empty, repeated-match, single-match, no-match, and unchanged-source tests

This is the current released exp-93 stdlib/source contract. It does not claim beta maturity or add automatic standard-library imports, compiler-loaded standard-library source, new compiler-known std.* runtime names, mutable vec locals, generic collections, slice/view types, vector payload widening, 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/reserve/shrink, sorting, mapping, filtering, iterators, optimizer guarantees, or stable ABI/layout/ownership.

Current exp-87 stdlib/source support:

std/vec_i32.slo retains the exp-76 direct, builder, query, option-query, simple real-program, transform, generated constructor, range, replace, remove, insert, subvec, and remove-range helper surface
std/vec_i32.slo adds exactly one new public helper, insert_range
insert_range ((values (vec i32)) (position i32) (inserted (vec i32))) -> (vec i32) inserts all of inserted into values at a valid position
if position < 0 or position > len(values), insert_range returns values unchanged
if 0 <= position < len(values), insert_range inserts all of inserted before the current element at position
if position == len(values), insert_range appends inserted at the end
the helper preserves the order of both vectors and leaves both source vectors unchanged
the result length is len(values) + len(inserted) for valid positions
the implementation is an ordinary compositional source helper over existing take, drop, and concat
examples/projects/std-import-vec_i32/ imports the expanded helper list and keeps deterministic middle insertion, append-at-end insertion, negative-position, out-of-range-position, and unchanged-source tests

This is the current released exp-87 stdlib/source contract. It does not claim beta maturity or add automatic standard-library imports, compiler-loaded standard-library source, new compiler-known std.* runtime names, mutable vec locals, generic collections, slice/view types, vector payload widening, 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/reserve/shrink, sorting, mapping, filtering, iterators, optimizer guarantees, or stable ABI/layout/ownership.

Current exp-86 stdlib/source support:

std/vec_i32.slo retains the exp-76 direct, builder, query, option-query, simple real-program, transform, generated constructor, range, replace, remove, insert, and subvec helper surface
std/vec_i32.slo adds exactly one new public helper, remove_range
remove_range ((values (vec i32)) (start i32) (end_exclusive i32)) -> (vec i32) removes the half-open range [start, end_exclusive) from values
if start < 0, end_exclusive <= start, or start >= len(values), remove_range returns values unchanged
if end_exclusive >= len(values), remove_range removes the tail from start
the helper preserves the order of the remaining elements and leaves the source vector unchanged
the implementation is an ordinary compositional source helper over existing take, drop, and concat
examples/projects/std-import-vec_i32/ imports the expanded helper list and keeps deterministic middle-range removal, tail removal, end_exclusive <= start, out-of-range-start, negative-start, and unchanged-source tests

This is the current released exp-86 stdlib/source contract. It does not claim beta maturity or add automatic standard-library imports, compiler-loaded standard-library source, new compiler-known std.* runtime names, mutable vec locals, generic collections, slice/view types, vector payload widening, 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/reserve/shrink, sorting, mapping, filtering, iterators, optimizer guarantees, or stable ABI/layout/ownership.

Current exp-85 stdlib/source support:

std/vec_i32.slo retains the exp-76 direct, builder, query, option-query, simple real-program, transform, generated constructor, range, replace, remove, and insert helper surface
std/vec_i32.slo adds exactly one new public helper, subvec
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), subvec returns (empty)
if end_exclusive > len(values), subvec returns the remaining tail from start
the helper preserves source order and leaves the source vector unchanged
the helper is an ordinary copied vec helper, not a slice/view type
the implementation is an ordinary compositional source helper over existing take and drop
examples/projects/std-import-vec_i32/ imports the expanded helper list and keeps deterministic middle-range, tail-truncation, empty-range, out-of-range, negative-start, and unchanged-source tests

This is the current released exp-85 stdlib/source contract. It does not claim beta maturity or add automatic standard-library imports, compiler-loaded standard-library source, new compiler-known std.* runtime names, mutable vec locals, generic collections, slice/view types, vector payload widening, broader copied subvector/window helper families beyond subvec, public insert/remove/edit families beyond subvec, insert_at, replace_at, and remove_at, mutating vec APIs, capacity/reserve/shrink, sorting, mapping, filtering, iterators, optimizer guarantees, or stable ABI/layout/ownership.

Current exp-84 stdlib/source support:

std/vec_i32.slo retains the exp-76 direct, builder, query, option-query, simple real-program, transform, generated constructor, range, replace, and remove helper surface
std/vec_i32.slo adds exactly one new public helper, insert_at
insert_at ((values (vec i32)) (position i32) (value i32)) -> (vec i32) returns a new vector for valid insertions while preserving source order
if 0 <= position < len(values), insert_at inserts value before the current element at position
if position == len(values), insert_at appends value at the end
if the insertion is valid, the result length is len(values) + 1
if position < 0 or position > len(values), insert_at returns values unchanged
the helper does not mutate the source vector
the implementation is an ordinary compositional source helper over existing append, take, drop, and concat
examples/projects/std-import-vec_i32/ imports the expanded helper list and keeps deterministic middle-insert, append-at-end, negative, and out-of-range insertion tests

This is the current released exp-84 stdlib/source contract. It does not claim beta maturity or add automatic standard-library imports, compiler-loaded standard-library source, new compiler-known std.* runtime names, mutable vec locals, generic collections, slice types, vector payload widening, public insert/remove/edit families beyond insert_at, replace_at, and remove_at, mutating vec APIs, capacity/reserve/shrink, sorting, mapping, filtering, iterators, optimizer guarantees, or stable ABI/layout/ownership.

Current exp-82 stdlib/source support:

std/vec_i32.slo retains the exp-76 direct, builder, query, option-query, simple real-program, transform, generated constructor, and range helper surface
std/vec_i32.slo adds exactly one new public helper, replace_at
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), replace_at returns values unchanged
the helper does not mutate the source vector
the implementation is an ordinary compositional source helper over existing append, take, drop, and concat
examples/projects/std-import-vec_i32/ imports the expanded helper list and keeps deterministic in-range, negative, and out-of-range replacement tests

This is the current released exp-82 stdlib/source contract. It does not claim beta maturity or add automatic standard-library imports, compiler-loaded standard-library source, new compiler-known std.* runtime names, mutable vec locals, generic collections, slice types, vector payload widening, public insert/remove/edit families beyond replace_at, mutating vec APIs, capacity/reserve/shrink, sorting, mapping, filtering, iterators, optimizer guarantees, or stable ABI/layout/ownership.

Current exp-81 stdlib/source support:

std/vec_i32.slo retains the exp-76 direct, builder, query, option-query, simple real-program, transform, and generated constructor helper surface
std/vec_i32.slo adds exactly one new public helper, range
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 range returns an empty vector when end_exclusive <= start
generation stays private through an ordinary recursive source helper over existing append and empty vec facade operations
range_from_zero remains public and may delegate to range 0 count
examples/projects/std-import-vec_i32/ imports the expanded helper list and keeps deterministic negative, empty, and positive ascending tests

This is the current released exp-81 stdlib/source contract. It does not claim beta maturity or add automatic standard-library imports, compiler-loaded standard-library source, new compiler-known std.* runtime names, mutable vec locals, generic collections, slice types, vector payload widening, descending or stepped range variants, inclusive range variants, edit helpers, mutating vec APIs, capacity/reserve/shrink, sorting, mapping, filtering, iterators, optimizer guarantees, or stable ABI/layout/ownership.

Current exp-80 stdlib/source support:

std/vec_i32.slo retains the exp-76 direct, builder, query, option-query, simple real-program, and transform helper surface
std/vec_i32.slo adds generated constructor helpers repeat and range_from_zero
the new helpers are ordinary recursive source helpers over existing append and empty vec facade operations
repeat returns an empty vector when count <= 0
range_from_zero returns 0..count with an exclusive upper bound and returns an empty vector when count <= 0
examples/projects/std-import-vec_i32/ imports the expanded helper list and keeps deterministic explicit standard-source tests

This is a released experimental alpha exp-80 stdlib/source fixture. It does not claim beta maturity or add automatic standard-library imports, compiler-loaded standard-library source, new compiler-known std.* runtime names, mutable vec locals, generic collections, slice types, vector payload widening, mutating vec APIs, capacity/reserve/shrink, sorting, mapping, filtering, iterators, optimizer guarantees, or stable ABI/layout/ownership.

Current exp-78 stdlib/source support:

std/cli.slo keeps the exp-72 helper list unchanged
std/cli.slo keeps std.process and std.string as its only direct standard-source dependencies
the Slovo-side contract now explicitly freezes this facade for the sibling Glagol local-source gate
no source edit to std/cli.slo is required for this release

This is a released experimental alpha exp-78 contract-alignment fixture. It does not claim beta maturity or add automatic standard-library imports, compiler-loaded standard-library source, package registry behavior, shell parsing, option/flag parsing, subcommands, environment-backed configuration, optimizer guarantees, stable ABI/layout/ownership, or a std.slo aggregator.

Current exp-55 language/tooling support:

examples/supported/result-f64-bool-match.slo
source constructors for (result f64 i32) and (result bool i32)
source match with f64 and bool ok payload bindings and i32 err payload bindings
std.cli uses this support to propagate missing argument indexes for all typed helper result families

This is a released experimental alpha exp-55 source-flow fixture. It does not claim beta maturity or add generic result types, result payload families beyond the already promoted concrete families, generic result combinators, optimizer guarantees, or stable ABI/layout/ownership.

Current exp-60 stdlib/source support:

std/string.slo
retained len, concat, and concrete parse_*_result wrappers
added parse_i32_or_zero, parse_i64_or_zero, parse_f64_or_zero, and parse_bool_or_false
ordinary source match over existing concrete i32, i64, f64, and bool parse result families
examples/projects/std-import-string/ imports the expanded helper list and keeps deterministic tests on both direct parse results and fallback helpers

This is a released experimental alpha exp-60 stdlib/source fixture. It does not claim beta maturity or add automatic standard-library imports, compiler-loaded std/ source, generic parse helpers, whitespace trimming, case-insensitive bool parsing, rich parse errors, optimizer guarantees, or stable ABI/layout/ownership.

Current exp-61 stdlib/source support:

std/process.slo
retained argc, arg, arg_result, and has_arg
added arg_or and arg_or_empty
ordinary source match over the existing (result string i32) process argument family
examples/projects/std-import-process/ imports the expanded helper list and keeps deterministic tests on both missing-index and present-index flows

This is a released experimental alpha exp-61 stdlib/source fixture. It does not claim beta maturity or add automatic standard-library imports, compiler-loaded std/ source, shell parsing, option/flag parsing, subcommands, process spawning, exit/status control, rich host errors, optimizer guarantees, or stable ABI/layout/ownership.

Current exp-56 language/stdlib support:

examples/supported/integer-remainder.slo
examples/formatter/integer-remainder.slo
% binary operator over same-width i32 and i64 operands
formatter/checker/test-runner/LLVM support for integer signed remainder
std/math.slo helpers: rem_i32, is_even_i32, is_odd_i32, rem_i64, is_even_i64, and is_odd_i64
explicit std.math import fixture coverage for the expanded helper list

This is a released experimental alpha exp-56 numeric/stdlib fixture. It does not claim beta maturity or add floating-point remainder, Euclidean modulo, unsigned arithmetic, bit operations, generic math, mixed numeric arithmetic, optimizer guarantees, or stable ABI/layout/ownership.

Current exp-57 language/stdlib support:

examples/supported/integer-bitwise.slo
examples/formatter/integer-bitwise.slo
bit_and, bit_or, and bit_xor binary heads over same-width i32 and i64 operands
formatter/checker/test-runner/LLVM support for integer bitwise operations
std/math.slo helpers: bit_and_i32, bit_or_i32, bit_xor_i32, bit_and_i64, bit_or_i64, and bit_xor_i64

This is a released experimental alpha exp-57 numeric/stdlib fixture. It does not claim beta maturity or add shifts, bit-not, unsigned arithmetic, bit-width-specific integer families, floating-point bitwise operations, generic math, mixed numeric arithmetic, optimizer guarantees, or stable ABI/layout/ownership.

Current exp-123 documentation/tooling support:

docs/SLOVO_WHITEPAPER.md refreshed to the current exp-121 language surface and exp-123 publication baseline
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 publication tables are widened from seven rows to nine in the controller-owned benchmark refresh pass
generated PDF artifacts remain published through scripts/render-doc-pdfs.sh
compatibility WHITEPAPER.pdf remains mirrored from the canonical docs PDF
explicit release metadata keeps exp-121 as the latest language-surface slice while exp-123 is the current publication baseline

This is a released experimental alpha exp-123 documentation/tooling fixture. It does not claim beta maturity or add source syntax, type forms, standard-library APIs, optimizer guarantees, benchmark thresholds, cross-machine performance claims, stable ABI/layout/ownership, package registry behavior, or language-surface changes.

Current exp-58 language support:

examples/supported/boolean-logic.slo
examples/formatter/boolean-logic.slo
(and left right) and (or left right) as short-circuiting boolean forms
(not value) as a boolean negation form
lowering through existing if, so no new LLVM primitive is required

This is a released experimental alpha exp-58 boolean logic fixture. It does not claim beta maturity or add truthiness, variadic boolean operators, pattern guards, macro expansion, optimizer guarantees, or stable ABI/layout/ownership.

Current exp-24 fixture support:

examples/supported/integer-to-string.slo
examples/formatter/integer-to-string.slo
std.num.i32_to_string : (i32) -> string
std.num.i64_to_string : (i64) -> string
decimal signed ASCII strings with - only for negative values and no leading +
existing string equality, std.string.len, and std.io.print_string
top-level tests and main returning i32

This is a released experimental alpha exp-24 fixture. It does not claim beta maturity or add f64 formatting, parse APIs, locale/base/radix/grouping or padding controls, generic format/display traits, implicit conversions, stable ABI/layout and ownership, manifest schema, or standard-library breadth.

Current exp-5 fixture support:

examples/workspaces/exp-5-local/
one workspace manifest with explicit local members
two package manifests with package name/version metadata
one local path dependency
one package-qualified import
deterministic local package graph recording in artifact manifests

These are current compiler-supported exp-5 fixtures.

Current compiler-supported exp-6 fixture:

examples/ffi/exp-6-c-add/
top-level imported C function declaration for c_add
i32-only scalar parameters and i32 return
lexical (unsafe ...) required at every imported C call site
safe Slovo wrapper around (unsafe (c_add 40 2))
fixture-scoped native C companion source, with no stable ABI/layout promise

These are current compiler-supported exp-6 fixtures after matching Slovo and Glagol exp-6 gates.

v1 scope-freeze decisions:

struct field/value mutation remains deferred beyond v1 unless explicitly promoted later
option/result mapping, equality, printing, payloads and extraction beyond the explicitly promoted (result i32 i32), (result string i32), and (result i64 i32) concrete slices, nesting, containers, generic payloads, payload ADTs, and user-catchable exceptions remain deferred unless explicitly promoted later
unit printing is unsupported in v1.2; print_unit remains deferred
unit remains an internal builtin result type for supported unit-producing body forms; user-declared or stored unit values remain unsupported
standard-runtime printing beyond v1.5 std.io.print_i32, std.io.print_string, and std.io.print_bool, exp-20 std.io.print_f64, and exp-21 std.io.print_i64 remains deferred
std.io.print_unit, host IO beyond the exp-3 slice, exp-10 *_result slice, and exp-12 stdin-result slice, parsing beyond exp-13 std.string.parse_i32_result, exp-25 std.string.parse_i64_result, and exp-28 std.string.parse_f64_result, plus exp-34 exact lowercase std.string.parse_bool_result, time, randomness beyond exp-11, user-visible allocation, integer formatting beyond exp-24, f64 formatting beyond exp-26 finite text, locale/base/radix/grouping/padding formatting controls, user-defined standard modules, overloading, generic APIs, Unicode length or digit semantics, and ABI/layout promises remain deferred
lexical unsafe remains the only accepted unsafe boundary; v1.6 reserves raw unsafe operation heads for gating diagnostics, but pointer types, allocation, deallocation, load, store, pointer arithmetic, reinterpretation, unchecked indexing, raw memory execution, and FFI remain deferred
stable ABI and stable layout promises remain deferred; v1.6 keeps memory direction staged toward safe values by default, future affine ownership, and explicit unsafe regions

v1.1 tooling release decisions:

v1.1 is a tooling release over v1 semantics, not a source language release.
The canonical v1.1 commands are glagol check <file.slo>, glagol fmt <file.slo>, glagol test <file.slo>, and glagol build <file.slo> -o <binary>.
v1.1 assumes slovo.diagnostic version 1, slovo.artifact-manifest version 1, JSON diagnostics on request, artifact manifests on request, a hosted native build path through LLVM IR, Glagol runtime C, and Clang, and the stable exit-code table from .llm/V1_1_TOOLCHAIN_PRODUCTIZATION.md.
Compatibility aliases may remain only as Glagol-side aliases that route through the canonical command behavior; Slovo docs teach the canonical commands.
Project mode, package management, multi-file modules, write-in-place formatting, test filtering, build profiles, cross-compilation, stable ABI, object/library/header output, FFI, LSP, SARIF, and daemon protocols stay deferred.

v1.2 practical runtime values release decisions:

v1.2 is a conservative source-language release over the v1.1 toolchain contract.
The precise Slovo-side contract is .llm/V1_2_PRACTICAL_RUNTIME_VALUES.md.
Runtime strings still originate only from immutable compiler-emitted source literals and propagation of those values; v1.2 adds no allocation, ownership, deallocation, stable ABI, or FFI promise.
String concatenation stays deferred in v1.2 because it requires allocation, ownership, lifetime, and deallocation semantics; exp-1 later stages only the narrow std.string.concat contract.
Runtime trap messages are stable for array bounds and option/result unwrap failures, are written to stderr with a trailing newline, and exit the process with code 1.
v1.2 preserves v1.1 single-file CLI/toolchain assumptions and does not add project mode, imports, packages, or multi-file modules.

v1.3 project mode and modules release decisions:

v1.3 is a conservative project-mode release over the v1.2 language and toolchain contract.
The precise Slovo-side contract is .llm/V1_3_PROJECT_MODE_AND_MODULES.md.
Project mode is selected only when glagol check, glagol test, or glagol build receives a project root containing slovo.toml or the slovo.toml file itself.
Passing one .slo file keeps the v1.2 single-file behavior unchanged.
slovo.toml uses a minimal [project] schema with required name, optional source_root defaulting to src, and optional entry defaulting to main; the detailed .llm contract is normative for identifier, unknown-key, and path-boundary validation.
v1.3 project modules are flat local .slo files directly under the source root; each file stem must match its (module name ...) declaration.
Imports are explicit local imports of exported names only; there are no packages, dependencies, registries, version solving, workspaces, aliases, glob imports, qualified names, or re-exports.
Only top-level fn and struct declarations listed in a module export list are importable.
Duplicate-name, missing-import, import-cycle, ambiguous-name, and visibility failures are required structured diagnostics with multi-file source spans.
AmbiguousName means the same unqualified name was imported from different modules; duplicate names within one import list remain DuplicateName.
Module discovery, graph validation, test execution, diagnostics, and artifact manifests use deterministic ordering.

v1.4 core language expansion release decisions:

v1.4 is a conservative source-language release over the v1.3 project-mode and v1.2 runtime-values contracts.
The precise Slovo-side contract is .llm/V1_4_CORE_LANGUAGE_EXPANSION.md.
v1.4 promotes source-level match only for existing (option i32), (option i64), and (result i32 i32) values.
Option matches require exactly some and none; result matches require exactly ok and err.
Payload bindings for some, ok, and err are immutable and scoped only to the selected arm.
Match arm bodies may contain one or more expressions; the final expression is the arm value.
The match expression type is the common arm result type. Mismatches are structured diagnostics.
Existing tag observers and unwrap_* forms remain supported, but new option/result payload examples prefer match.
v1.4 does not promote user-defined enums/ADTs, generic payloads, mutation, vectors, i64, general block expressions, pattern guards, wildcard/rest patterns, destructuring, standard-library error conventions, ownership, or layout/ABI promises.

v1.5 standard library alpha release decisions:

v1.5 is a conservative standard-runtime naming release over the v1.4 contract.
The precise Slovo-side contract is .llm/V1_5_STANDARD_LIBRARY_ALPHA.md.
v1.5 promotes only std.io.print_i32, std.io.print_string, std.io.print_bool, and std.string.len.
These names are compiler-known source-level standard-runtime names, not user modules, imports, package dependencies, foreign functions, or stable C ABI symbols.
std.io.print_i32 accepts exactly one i32, returns builtin unit, and keeps legacy print_i32 stdout behavior.
std.io.print_string accepts exactly one string, returns builtin unit, and keeps legacy print_string stdout behavior and string-literal constraints.
std.io.print_bool accepts exactly one bool, returns builtin unit, and keeps legacy print_bool stdout behavior.
std.string.len accepts exactly one string, returns i32, and keeps legacy string_len decoded-byte count semantics.
Legacy print_i32, print_string, print_bool, and string_len remain compatibility aliases, but new examples prefer std.* names.
Promoted std.* names are reserved from user function/export shadowing.
Unknown or unpromoted std.* calls use structured diagnostics; the suggested diagnostic code is UnsupportedStandardLibraryCall.
Arity and type mismatches for promoted std.* calls use existing arity/type diagnostics where applicable.
v1.5 does not promote std.io.print_unit, file IO, environment variables, process arguments, time, vectors/collections, allocation, user-defined standard modules, imports/packages, overloading, generic APIs, Unicode length semantics, or ABI/layout promises.

v1.6 memory and unsafe design slice release decisions:

v1.6 was released 2026-05-17.
The precise Slovo-side contract is .llm/V1_6_MEMORY_UNSAFE_SLICE.md.
v1.6 promotes a reservation and gating contract, not raw-memory execution.
Lexical (unsafe ...) remains the only unsafe boundary.
alloc, dealloc, load, store, ptr_add, unchecked_index, reinterpret, and ffi_call are compiler-known reserved unsafe heads.
Safe code using a reserved unsafe head must receive UnsafeRequired before ordinary call lookup.
Code inside (unsafe ...) using a reserved unsafe head must receive UnsupportedUnsafeOperation until a future release defines semantics.
User functions, imports, exports, and parameters cannot shadow reserved unsafe heads.
Memory direction remains staged: safe values by default, future affine ownership, and explicit unsafe regions.
v1.6 does not promote pointer types, allocation/free, load/store, pointer arithmetic, unchecked indexing, raw reinterpretation, FFI, stable ABI, or stable layout.

v1.7 developer experience hardening release decisions:

v1.7 was released 2026-05-17.
The precise Slovo-side contract is .llm/V1_7_DEVELOPER_EXPERIENCE_HARDENING.md.
v1.7 is a tooling-only release over the v1.6 language contract.
glagol new <project-dir> [--name <name>] scaffolds a valid v1.3-style project with slovo.toml, src/main.slo, and a small testable main module.
glagol new must fail without overwriting non-empty directories.
Plain glagol fmt <file.slo> remains stdout formatting.
glagol fmt --check <file-or-project> checks canonical formatting without writing files.
glagol fmt --write <file-or-project> writes canonical formatting for one file or all immediate project source modules.
glagol doc <file-or-project> -o <dir> generates deterministic Markdown from source structure: modules, imports/exports, structs, functions, and tests.
Documentation generation is not a semantic reflection API and does not claim typed-core, debug metadata, source-map, ABI, layout, or runtime reflection stability.
A repo script or documented command entry point must run the full local v1 release gate.
LSP, watch mode, daemon protocols, SARIF, debug adapters, stable debug metadata, DWARF, and stable source-map files remain deferred.

v2.0.0-beta.1 experimental integration/readiness release decisions:

v2.0.0-beta.1 is a historical experimental release contract, released 2026-05-17. The pushed tag name is historical and is not a beta maturity claim.
The precise Slovo-side contract is .llm/V2_0_0_BETA_1_RELEASE_CONTRACT.md.
Experimental readiness is based on v1.7 and adds no new source language syntax or semantics unless already implemented and gate-proven in Glagol.
Experimental readiness means small real flat local projects can use glagol new, check, fmt --check, fmt --write, test, build, doc, artifact manifests, JSON diagnostics, and the release-gate script as one integrated workflow.
The experimental language surface is the accumulated v1.1-v1.7 surface: i32, bool, builtin internal unit, tests, locals, if, while, structs, fixed direct scalar arrays with checked indexing, string value flow, option/result values and exact match slice, standard-runtime alpha, and lexical unsafe with reserved unsafe heads.
Basic IO is only std.io.print_i32, std.io.print_string, std.io.print_bool, and std.string.len; file/env/process/time IO remains deferred.
Vectors and growable collections are not experimental readiness requirements. Fixed arrays satisfy the experimental gate because this is an integration milestone; growable collections require allocation, ownership/lifetime, capacity, mutation, diagnostics, lowering, runtime tests, and docs that remain future beta work.
Stable ABI/layout, FFI, raw-memory execution, LSP, stable debug metadata, stable source-map files, and package registries remain future beta work.

exp-1 owned runtime strings release decisions:

exp-1 is the first experimental step toward 1.0.0-beta.
The precise Slovo-side contract is .llm/EXP_1_OWNED_RUNTIME_STRINGS.md.
exp-1 promotes exactly one new source-level operation: std.string.concat.
std.string.concat accepts two string values and returns 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 literal-backed and runtime-owned strings.
No legacy string_concat alias is introduced.
Allocation failure traps with slovo runtime error: string allocation failed and exits with code 1.
Runtime-owned string cleanup is compiler/runtime-owned and not source-visible.
exp-1 keeps mutable strings, string containers, string indexing/slicing, user-visible allocation/deallocation, file IO, packages, generics, growable collections, raw-memory execution, FFI, and stable ABI/layout deferred.

The matching Glagol exp-4 gate has passed. The next planned implementation stage is the next beta-roadmap slice after payloadless user-defined enums.

exp-2 collections alpha release decisions:

exp-2 is a current experimental compiler-supported contract after matching Glagol exp-2 gates.
The precise Slovo-side contract is .llm/EXP_2_COLLECTIONS_ALPHA.md.
exp-2 promotes exactly one concrete growable vector type: (vec i32).
exp-2 promotes exactly four compiler-known standard-runtime operations: std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, and std.vec.i32.index.
std.vec.i32.append accepts (vec i32) and i32 and returns a new immutable runtime-owned (vec i32) without mutating the input vector.
std.vec.i32.len returns i32; std.vec.i32.index returns i32 and traps on invalid indices.
Vector equality with = compares lengths and i32 element values in order.
Runtime trap texts are slovo runtime error: vector allocation failed and slovo runtime error: vector index out of bounds.
exp-2 keeps generic vectors, non-i32 element types, vector mutation, vector var/set, vector literals beyond empty/append construction, push, nested vectors, vectors in arrays/structs/options/results, iterators, slices, maps, sets, user-visible deallocation, stable ABI/layout/helper symbols, packages, and IO expansion deferred.

exp-3 standard IO and host environment release decisions:

exp-3 is a current experimental compiler-supported contract after matching Glagol exp-3 gates.
The precise Slovo-side contract is .llm/EXP_3_STANDARD_IO_HOST_ENV.md.
exp-3 promotes exactly six compiler-known standard-runtime operations: std.io.eprint, std.process.argc, std.process.arg, std.env.get, std.fs.read_text, and std.fs.write_text.
std.io.eprint accepts string, writes to stderr without adding a newline, and returns builtin unit.
std.process.argc returns i32; std.process.arg accepts i32 and returns string, trapping on out-of-range access with slovo runtime error: process argument index out of bounds.
std.env.get accepts string and returns string; missing variables return the empty string for this stage.
std.fs.read_text accepts string and returns string, trapping on host read failure with slovo runtime error: file read failed.
std.fs.write_text accepts two string values and returns 0 on success or 1 on host failure.
exp-3 keeps networking, async IO, binary file APIs, directory traversal, terminal control, platform abstraction, general host error ADTs, result string Error, package interaction, stdin full read/line iteration, randomness, time, stable ABI/layout, and stable helper symbols deferred.

exp-4 user data types and polymorphism release decisions:

exp-4 is a current experimental compiler-supported contract after matching Glagol exp-4 gates.
The precise Slovo-side contract is .llm/EXP_4_USER_ADTS_ALPHA.md.
exp-4 promotes only payloadless user-defined enums: (enum Name VariantA VariantB ...), with at least one variant.
Variant values are constructed only 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 supports exhaustive payloadless variant arms with pattern syntax ((Name.VariantA) body...), one-or-more expression bodies, and common final result types.
Runtime/backend representation is compiler-owned; exp-4 promises no stable layout, discriminant value, ABI, helper symbols, reflection, or conversion to i32.
exp-4 keeps payload variants, tuple/record variants, generic enums, generic functions, type aliases, traits/interfaces/protocols, methods, derives, variant payload binding, wildcard/rest patterns, guards, nested patterns, enum values in arrays/options/results/vectors or nested structs beyond exp-18 direct fields, enum mutation, enum printing/ordering/hash, reflection, explicit discriminants, constructors with arguments, unqualified variant constructors, stable ABI/layout, and moving option/result to ordinary standard-library types deferred.

exp-6 C FFI scalar imports alpha release decisions:

exp-6 is a released experimental contract, not beta maturity.
The precise Slovo-side contract is .llm/EXP_6_C_FFI_SCALAR_IMPORTS_ALPHA.md.
exp-6 promotes only top-level imported C function declarations with i32-only scalar parameters and i32 or internal unit returns.
Calls to imported C functions must occur inside lexical (unsafe ...).
examples/ffi/exp-6-c-add/ is the minimal fixture target, with a c_add C companion and a safe Slovo wrapper.
Artifact manifests must record foreign import metadata while marking the ABI/layout as experimental and fixture-scoped.
exp-6 keeps pointer types, allocation/deallocation, raw unsafe heads execution, ownership/lifetime rules, C exports, headers, libraries, broad linker configuration, and stable ABI/layout deferred.

exp-7 test selection and test-run metadata alpha target decisions:

exp-7 is a released experimental contract, not beta maturity.
The precise Slovo-side release contract is .llm/EXP_7_TEST_SELECTION_ALPHA.md.
exp-7 is narrowed to glagol test <file.slo|project> --filter <substring> plus legacy glagol --run-tests --filter <substring> <file.slo> while Glagol keeps the legacy route.
Filtering is deterministic, case-sensitive substring matching against test display names.
Selected tests execute in existing order; non-selected tests are skipped and counted.
Zero matches is a successful run with explicit discovered, selected, passed, failed, and skipped counts.
Test-run output and artifact manifests gain additive experimental metadata for total discovered, selected, passed, failed, skipped, and optional filter string.
exp-7 keeps LSP, debug metadata, source maps, SARIF, watch/daemon protocols, documentation comments, lint categories, benchmarks, and new source language syntax deferred.

exp-8 host time and sleep alpha release decisions:

exp-8 is a released experimental compiler-supported contract, not beta maturity.
The precise Slovo-side release contract is .llm/EXP_8_HOST_TIME_SLEEP_ALPHA.md.
exp-8 narrows the broad concurrency and long-running programs roadmap category to exactly std.time.monotonic_ms: () -> i32 and std.time.sleep_ms: (i32) -> unit.
std.time.monotonic_ms returns non-negative host monotonic elapsed milliseconds with an implementation-owned epoch.
std.time.sleep_ms accepts non-negative i32 millisecond durations; 0 is valid, and negative values reject or trap with slovo runtime error: sleep_ms negative duration.
Test-runner support is deterministic for sleep_ms 0; monotonic_ms support is limited to structural tests or a non-negative host value.
The exp-14 conformance-alignment release adds byte-identical Slovo fixtures examples/supported/time-sleep.slo and examples/formatter/time-sleep.slo for this already released exp-8 behavior.
Artifact manifests record standard-runtime time usage only if existing manifest patterns support standard-runtime usage metadata; otherwise extra time-specific metadata is deferred.
exp-8 keeps threads, tasks, channels, async, cancellation, actors, shared memory, data-race freedom, scheduling guarantees, timers, wall-clock/ calendar/timezone APIs, high-resolution timers, signal handling, source syntax, stable ABI/layout, and stable runtime helper symbols deferred.

exp-9 reliability, performance, and ecosystem hardening release decisions:

exp-9 is a released experimental compiler-supported contract, not beta maturity.
The precise Slovo-side release contract is .llm/EXP_9_RELIABILITY_PERFORMANCE_ECOSYSTEM_HARDENING.md.
exp-9 is hardening-only over the released exp-8 baseline. It adds no source language syntax, type-system behavior, standard-runtime names, package features, manifest schema versions, runtime capabilities, stable ABI/layout promises, public performance guarantees, or beta claim.
Matching Glagol gates must include property/fuzz-style parser, formatter, diagnostic, project graph, and promoted runtime API tests where feasible.
Matching Glagol gates must include a source-reachable panic audit covering compiler, formatter, diagnostic, project graph, test-runner, backend, artifact-manifest, and runtime API paths.
Matching Glagol gates must include 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 keeps all language, standard-library, package-management, editor protocol, debug/source-map, broad FFI, raw-memory execution, stable benchmark-suite, stable ABI/layout, and beta-maturity expansion deferred.

exp-10 result-based host errors alpha release decisions:

exp-10 is a released experimental compiler-supported contract, not beta maturity.
The precise Slovo-side release contract is .llm/EXP_10_RESULT_BASED_HOST_ERRORS_ALPHA.md.
exp-10 promotes exactly one new concrete result family: (result string i32).
exp-10 promotes exactly four additive compiler-known standard-runtime operations: std.process.arg_result, std.env.get_result, std.fs.read_text_result, and std.fs.write_text_result.
The only promised ordinary host failure code is err 1.
std.fs.write_text_result returns ok 0 on success and err 1 on ordinary host write failure.
The existing exp-3 calls remain unchanged.
Artifact manifests record exp-10 standard-runtime usage only if existing manifest patterns already record standard-runtime usage metadata; otherwise exp-10 adds no manifest schema fields.
exp-10 keeps general host error ADTs, result string Error, platform-specific codes, result equality/printing/mapping, broader host API families, stable ABI/layout/helper symbols, and beta maturity deferred.

exp-11 basic randomness alpha release decisions:

exp-11 is released experimental compiler support and not beta maturity.
The precise Slovo-side release contract is .llm/EXP_11_BASIC_RANDOMNESS_ALPHA.md.
exp-11 promotes exactly one compiler-known standard-runtime operation: std.random.i32: () -> i32.
std.random.i32 returns a non-negative implementation-owned pseudo-random or host-random i32 suitable only for basic CLI use.
Runtime/host inability to produce a value traps with exactly slovo runtime error: random i32 unavailable.
Glagol test-runner behavior may use an implementation-owned deterministic non-negative sample or sequence.
Artifact manifests record exp-11 standard-runtime usage only if existing manifest patterns already record standard-runtime usage metadata; otherwise exp-11 adds no manifest schema fields.
exp-11 keeps seed APIs, crypto/security promises, bytes APIs, ranges, bounds, floats, random strings, UUIDs, broad std.random.*, stable ABI/layout/helper symbols, and beta maturity deferred.

exp-12 standard input result alpha release decisions:

exp-12 is released experimental compiler support and not beta maturity.
Release date: 2026-05-18.
The precise Slovo-side release contract is .llm/EXP_12_STDIN_RESULT_ALPHA.md.
exp-12 promotes exactly one compiler-known standard-runtime operation: std.io.read_stdin_result: () -> (result string i32).
std.io.read_stdin_result reads remaining stdin as text, returns ok text on success, returns ok "" for ordinary EOF with no bytes, and returns (err string i32 1) for ordinary host/input failure.
Glagol test-runner behavior may use an implementation-owned fixed ok string.
Artifact manifests record exp-12 standard-runtime usage only if existing manifest patterns already record standard-runtime usage metadata; otherwise exp-12 adds no manifest schema fields.
exp-12 keeps trap stdin, line/prompt/terminal/binary/streaming/async stdin, encoding or Unicode promises beyond existing string bytes, stable ABI/layout/helper symbols, manifest schema changes, and beta maturity deferred.

exp-13 string parse i32 result alpha release decisions:

exp-13 is released experimental compiler support and not beta maturity.
Release date: 2026-05-18.
The precise Slovo-side release contract is .llm/EXP_13_STRING_PARSE_I32_RESULT_ALPHA.md.
exp-13 promotes exactly one compiler-known standard-runtime operation: std.string.parse_i32_result: (string) -> (result i32 i32).
std.string.parse_i32_result parses the entire string as ASCII decimal signed i32, with optional leading - and at least one 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).
The only ordinary parse error code promised by exp-13 is err 1.
Release fixtures are examples/supported/string-parse-i32-result.slo and examples/formatter/string-parse-i32-result.slo.
exp-13 keeps trap-based parse, parsing floats/bools/strings/bytes, whitespace/locale/base-prefix/underscore/plus-sign parsing, generic parse, parse error messages/codes, Unicode digit parsing, string indexing/slicing, tokenizer/scanner APIs, stdin line APIs, stable ABI/layout/helper symbols, manifest schema fields, and beta maturity deferred.

exp-14 standard runtime conformance alignment release decisions:

exp-14 is released experimental conformance alignment and not beta maturity.
The precise Slovo-side target contract is .llm/EXP_14_STANDARD_RUNTIME_CONFORMANCE_ALIGNMENT.md.
exp-14 adds STANDARD_RUNTIME.md as the promoted compiler-known std.* operation catalog through exp-13.
exp-14 adds byte-identical canonical fixtures examples/supported/time-sleep.slo and examples/formatter/time-sleep.slo for already released exp-8 std.time.monotonic_ms and std.time.sleep_ms 0.
The time/sleep fixtures require only structural/non-negative monotonic-time behavior and deterministic sleep_ms 0; they do not assert positive-duration timing.
exp-14 requires the current supported fixture inventory to stay explicit and requires Slovo/Glagol supported and formatter fixtures to stay byte-aligned where matching files exist.
exp-14 requires a fresh-project workflow covering new, check, fmt --check, test, doc, and build where the hosted toolchain exists.
The workflow must exercise existing features together: modules/imports, tests, strings, std.string.concat, std.string.parse_i32_result, result match, (vec i32), enum match, and std.io.print_i32.
exp-14 release gates still include Slovo and Glagol diff checks, cargo fmt --check, cargo test, ignored promotion gate, binary smoke, LLVM smoke, and review PASS.
exp-14 release gates passed with Slovo and 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 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-15 result helper standard names alpha decisions:

The precise Slovo-side target contract is .llm/EXP_15_RESULT_HELPER_STANDARD_NAMES_ALPHA.md.
exp-15 promotes preferred source-level std.result.is_ok, std.result.is_err, std.result.unwrap_ok, and std.result.unwrap_err.
The names are accepted only for (result i32 i32) and (result string i32).
Legacy unqualified result helpers remain compatibility syntax where already supported.
Release fixtures are examples/supported/result-helpers.slo and examples/formatter/result-helpers.slo.
exp-15 keeps 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, and beta maturity deferred.

exp-17 project enum imports alpha decisions:

The precise Slovo-side target contract is .llm/EXP_17_PROJECT_ENUM_IMPORTS_ALPHA.md.
exp-17 promotes explicit export/import of top-level enum names across local project modules and exp-5 workspace package modules.
Imported enum types can be used in function signatures, immutable locals, calls/returns, same-enum equality, exhaustive enum matches, and qualified constructors.
The enum surface is exactly exp-4 payloadless variants plus exp-16 unary i32 payload variants.
The project fixture is examples/projects/enum-imports/.
exp-17 keeps non-i32 enum payloads, multiple payloads, generics, containers, mutation, printing, ordering, hashing, reflection, stable ABI/layout, manifest schema changes, registry/package-manager claims, and beta maturity deferred.

exp-18 enum struct fields alpha decisions:

The precise Slovo-side target contract is .llm/EXP_18_ENUM_STRUCT_FIELDS_ALPHA.md.
exp-18 promotes direct struct field declarations whose field types are current user-defined enum type names.
The enum field surface is exactly exp-4 payloadless variants plus exp-16 unary i32 payload variants.
Struct construction, immutable struct local/parameter/return/call flow, field access, same-enum equality on field access, enum match on field access, tests, and main are in scope.
Release fixtures are examples/supported/enum-struct-fields.slo and examples/formatter/enum-struct-fields.slo.
exp-18 keeps wider enum payloads, arrays/vectors/options/results containing enum values, nested structs, struct mutation, enum mutation, printing, ordering, hashing, reflection, import aliases/globs/re-exports, stable ABI/layout, manifest schema changes, registry/package-manager claims, generics, and beta maturity deferred.

exp-19 primitive struct fields alpha decisions:

The precise Slovo-side target contract is .llm/EXP_19_PRIMITIVE_STRUCT_FIELDS_ALPHA.md.
exp-19 promotes direct struct field declarations whose field types are bool or immutable string, alongside already supported direct i32 and exp-18 enum fields.
Struct construction, immutable struct local/parameter/return/call flow, field access, bool predicate/test use, string equality, std.string.len, tests, and main are in scope.
Release fixtures are examples/supported/primitive-struct-fields.slo and examples/formatter/primitive-struct-fields.slo.
exp-19 keeps arrays/vectors/options/results, nested structs, struct mutation, string mutation, string ownership/cleanup guarantees beyond existing string behavior, broader string operations, printing beyond existing calls, package/import widening, stable ABI/layout, manifest schema changes, generics, methods, traits, and beta maturity deferred.

exp-20 f64 numeric primitive alpha decisions:

The precise Slovo-side target contract is .llm/EXP_20_F64_NUMERIC_PRIMITIVE_ALPHA.md.
exp-20 promotes direct f64 function parameters, returns, immutable locals, calls, and decimal literals in f64 contexts.
Same-type f64 +, -, *, /, =, <, >, <=, and >= plus std.io.print_f64, tests, and main returning i32 are in scope.
Release fixtures are examples/supported/f64-numeric-primitive.slo and examples/formatter/f64-numeric-primitive.slo.
exp-20 keeps f32, wider/common integer types, char/bytes/decimal, numeric casts, mixed i32/f64 arithmetic, f64 arrays/vectors/options/results, f64 enum payloads, f64 struct fields, parse_f64, random floats, stable ABI/layout, manifest schema changes, and beta maturity deferred.

Phase 1: Stabilize The Contract

Split examples into compiler-supported and design/speculative groups.
Mark which examples Glagol can currently parse, check, and emit.
Keep examples/supported/add.slo aligned with Glagol's executable target.
Add notes to speculative examples saying they are design targets, not current compiler fixtures.
Keep SPEC-v0.md explicit about unimplemented v0 forms.
Keep README and examples docs explicit about the current supported subset.
Keep supported examples free of any form outside the current compiler contract.

Phase 2: Make Tooling Real

Define canonical formatter rules for current supported syntax only.
Add formatter examples for modules, functions, calls, integer literals, print_i32, and binary +.
Add formatter examples for comparison and top-level test only after those forms become supported or are explicitly documented as design-target fixtures.
Add Slovo formatter fixtures for top-level test only after Glagol implements and tests the full strict contract.
Define parsed-tree printer output.
Define lowering-inspector output from surface AST to checked/core AST.
Define machine-diagnostic fixture format.

Phase 3: Close Spec Gaps

Specify exact supported integer-literal range behavior for i32.
Specify print_i32 as either a temporary compiler intrinsic or a standard-library/runtime binding.
Specify whether unit can be used as a user-declared return type in supported fixtures.
Specify when checked-but-not-lowered forms must emit UnsupportedBackendFeature instead of panicking.
Specify top-level test behavior enough for Glagol to implement it.
Coordinate remaining Glagol contract fixes and promotion tests before moving any test example into examples/supported/.
Specify let, var, and set checking and lowering.
Specify while checking and lowering.
Specify checked-expression spans as part of the compiler contract.
Specify line/column diagnostic ranges in addition to byte spans.
Specify the strict first-pass i32 struct contract.
Specify the strict first-pass i32 array constructor and literal checked-indexing contract.
Specify the strict first-pass i32 option/result constructor contract.

Phase 4: Grow The Core

Promote let, var, and set into supported examples and formatter fixtures.
Promote value-producing if into supported examples and formatter fixtures.
Promote first-pass while into supported examples and formatter fixtures.
Promote first-pass i32 struct definitions, construction, and field access into supported examples and formatter fixtures.
Promote first-pass arrays and checked indexing into supported examples and formatter fixtures.
Promote first-pass i32 option/result constructors into supported examples and formatter fixtures.
Promote lexical unsafe and unsafe-required diagnostics.
Runtime/string support or explicit unsupported diagnostics.

Phase 5: Close v0

Promote SPEC-v0.md from draft sketch to the supported v0 contract.
Keep Glagol's binary CLI as the implementation-facing v0 tool surface.
Keep direct executable output, package management, broader type flow, raw memory, FFI, and ABI layout promises deferred until separate contracts.

Phase 6: Start v1 Value Flow

Promote immutable struct locals, struct parameters, struct returns, calls returning structs, and field access through stored struct values.
Keep struct field/value mutation deferred beyond v1 unless explicitly promoted later.
Promote option/result value flow and tag observation.
Promote explicit trap-based i32 option/result payload extraction.
Keep option/result matching, mapping, equality, printing, non-i32 payloads and extraction, nested option/result values, arrays/structs containing option/results, and user-catchable exceptions deferred beyond v1 unless explicitly promoted later. v1.4 later promotes only the narrow (option i32) and (result i32 i32) match slice.
Promote array value flow, immutable array-local expression initialization, and dynamic indexing after layout and bounds behavior are specified.

Phase 7: Start Runtime Strings

Promote the narrow runtime string slice: immutable source string literals with ASCII-plus-current-escape semantics, direct print_string calls, and borrowed immutable NUL-terminated compiler-emitted static storage.
Keep mutable string locals, string assignment, string ordering/comparison beyond equality, string arrays/struct fields/option-result payloads, slices, concatenation, indexing, ownership, user-defined runtime bindings, and stable string ABI promises deferred until separate contracts promote them; exp-1 later stages only std.string.concat.
Keep standard-runtime printing deferred for this phase; v1.5 later promotes only std.io.print_i32, std.io.print_string, and std.io.print_bool over the existing legacy aliases.
Keep unit printing unsupported; bool printing is promoted separately in v1.2 through print_bool.
Keep unit internal to supported unit-producing body forms; user-declared or stored unit values remain unsupported in v1.

Phase 8: Improve v1 Tooling Contracts

Define slovo.diagnostic version 1 as the stable v1 machine diagnostic schema.
Define the v1 direction for preserving source spans through LLVM IR emission while deferring stable debug metadata and source-map files.
Define slovo.artifact-manifest version 1 for compiler outputs and test reports without requiring native executable output.
Define formatter stability guarantees for comments and nested forms: promoted formatter fixtures are idempotent canonical output, accepted full-line comment positions are preserved, unsupported comment/layout positions require structured diagnostics, if / while / unsafe keep stable multiline shapes, expression calls and constructors stay inline, and v1 makes no width-based reflow promise.
Specify the Stage 3 diagnostics coverage contract: Glagol must keep a golden machine-diagnostic fixture inventory for every current explicitly rejected v1 boundary. This marks the Slovo obligation as specified; it does not claim the Glagol inventory is complete.
Specify the Stage 3 lowering-inspector coverage contract: Glagol must keep textual inspector golden fixtures for add/canonical, top-level tests, locals, if, while, struct, struct value flow, array, array value flow, option/result, option/result flow, option/result payload, option/result match, string print, string value flow, print bool, unsafe, and formatter comments/stability only where inspector mode applies to source accepted by lowering.
Keep stable LLVM debug metadata, DWARF emission, and source-map files deferred; lowering-inspector fixtures are textual compiler-tree artifacts, not debug metadata.
Require future promoted features to add diagnostic and lowering-inspector coverage before promotion.

Phase 9: Productize v1.1 Toolchain

Freeze v1.1 as a tooling release over the v1 language contract.
Define canonical single-file commands for check, fmt, test, and build.
Keep v1 source semantics and unsupported boundaries unchanged.
Define JSON diagnostics as a serialization of slovo.diagnostic version 1.
Apply slovo.artifact-manifest version 1 manifests to v1.1 command invocations.
Define the stable v1.1 exit-code table.
Define hosted native build as LLVM IR plus Glagol runtime C plus Clang.
Document compatibility aliases as secondary Glagol routes, not primary Slovo commands.
Document v1.1 release gates and explicit deferrals.

Phase 10: Freeze v1.2 Practical Runtime Values

Promote immutable string locals, string parameters, string returns, calls returning strings, string equality, string byte length through string_len, and top-level tests using string equality.
Promote print_bool with exact true\n / false\n output.
Keep print_unit unsupported because unit remains an internal builtin result type rather than a user-visible value.
Keep string concatenation deferred until allocation, ownership, lifetime, and deallocation semantics are specified; exp-1 later specifies the first narrow std.string.concat operation.
Define stable runtime trap messages and process exit code 1 for array bounds and option/result unwrap failures.
Preserve v1.1 CLI/toolchain assumptions and keep project mode/modules deferred.

Phase 11: Freeze v1.3 Project Mode And Modules

Define slovo.toml as the v1.3 project manifest.
Define a flat source-root convention with default src.
Define project mode for glagol check, glagol test, and glagol build.
Keep single-file command behavior unchanged when the input is a .slo file.
Define module declarations, explicit local imports, and explicit export lists.
Limit importable declarations to exported top-level fn and struct names.
Require deterministic module ordering, test ordering, and manifest ordering.
Require multi-file source spans and artifact-manifest project fields.
Keep packages, dependencies, remote registries, version solving, workspaces, macros, public ABI, cross-package visibility, incremental builds, watch/LSP, path escapes, and generated code deferred.

Phase 12: Freeze v1.4 Core Language Expansion

Promote source-level match for existing (option i32) and (result i32 i32) values.
Require exhaustive some / none and ok / err arms.
Define immutable payload bindings scoped to one arm only.
Define match arm bodies as one-or-more expression bodies whose final expression is the arm value.
Define match expression type as the common arm result type.
Name diagnostics for non-option/result subjects, unsupported payload types, missing arms, duplicate arms, malformed patterns, arm type mismatches, binding collisions, and unsupported mutation/container combinations.
Keep v1.3 project mode and v1.2 runtime values unchanged.
Keep user-defined enums/ADTs, generic payloads, mutation, vectors, i64, general block expressions, pattern guards, wildcard/rest patterns, destructuring, standard-library error conventions, ownership, and layout/ABI promises deferred.

Phase 13: Freeze v1.5 Standard Library Alpha

Promote std.io.print_i32 as the stable source-level standard-runtime name for legacy print_i32 behavior.
Promote std.io.print_string as the stable source-level standard-runtime name for legacy print_string behavior.
Promote std.io.print_bool as the stable source-level standard-runtime name for legacy print_bool behavior.
Promote std.string.len as the stable source-level standard-runtime name for legacy string_len byte-count behavior.
Preserve legacy print_i32, print_string, print_bool, and string_len as compatibility aliases.
Require UnsupportedStandardLibraryCall diagnostics for unknown or unpromoted std.* calls.
Reserve promoted std.* names from user function/export shadowing.
Keep v1.5 names compiler-known, with no imports, packages, user-defined standard modules, or stable C ABI symbols.
Keep std.io.print_unit, file IO, environment variables, process args, time, vectors/collections, allocation, overloading, generic APIs, Unicode length semantics, and ABI/layout promises deferred.

Phase 14: Freeze v1.6 Memory And Unsafe Design Slice

Keep lexical (unsafe ...) as the only unsafe boundary.
Reserve alloc, dealloc, load, store, ptr_add, unchecked_index, reinterpret, and ffi_call as compiler-known unsafe heads.
Require UnsafeRequired in safe code and UnsupportedUnsafeOperation inside lexical unsafe for reserved unsafe heads.
Reject user functions, imports, exports, and parameters that shadow reserved unsafe heads.
Keep raw-memory execution, pointer types, allocation/free, load/store, pointer arithmetic, unchecked indexing, reinterpretation, FFI, stable ABI, and stable layout deferred.

Phase 15: Freeze v1.7 Developer Experience Hardening

Define glagol new <project-dir> [--name <name>] as a non-overwriting v1.3-style project scaffold command.
Preserve plain glagol fmt <file.slo> as stdout formatting.
Define glagol fmt --check <file-or-project> as non-writing canonical formatting verification.
Define glagol fmt --write <file-or-project> as in-place canonical formatting for one file or immediate project source modules.
Define glagol doc <file-or-project> -o <dir> as deterministic Markdown documentation generation from source structure.
Keep documentation generation separate from semantic reflection, typed-core APIs, debug metadata, source maps, ABI/layout, and runtime reflection.
Require a repo script or documented command entry point for the full local v1 release gate.
Keep LSP, watch mode, daemon protocols, SARIF, debug adapters, stable debug metadata, DWARF, and stable source-map files deferred.

Phase 16: Freeze v2.0.0-beta.1 Experimental Integration Readiness

Mark v2.0.0-beta.1 as a historical experimental release contract, released 2026-05-17, with future general-purpose beta work as the next planning horizon.
Define the release as an experimental integration/readiness release based on v1.7 rather than a new source-language release.
Require the small-flat-project workflow through glagol new, check, fmt --check, fmt --write, test, build, doc, artifact manifests, JSON diagnostics, and the release-gate script.
Freeze the experimental-supported language surface as the accumulated v1.1-v1.7 surface.
Limit experimental IO to std.io.print_i32, std.io.print_string, std.io.print_bool, and std.string.len; keep file/env/process/time IO deferred.
Reconcile older collection roadmap text by making fixed arrays sufficient for experimental readiness and deferring vectors/growable collections until future beta work.
Keep stable ABI/layout, FFI, raw-memory execution, LSP, stable debug metadata, stable source maps, and package registries out of the experimental release.

Phase 17: Freeze exp-1 Owned Runtime Strings

Define exp-1 as experimental maturity and not beta.
Promote only compiler-known std.string.concat as the first heap-created owned runtime string operation.
Keep one source type, string, with literal-backed and runtime-owned implementation value kinds hidden from source code.
Require existing string equality, std.string.len, std.io.print_string, locals, parameters, returns, and calls to work over runtime-owned strings.
Define allocation-failure trap text and exit behavior.
Keep mutable strings, string containers, indexing, slicing, user-visible allocation/deallocation, file IO, packages, generics, growable collections, FFI, raw memory, and stable ABI/layout deferred.
Implement and gate the matching Glagol exp-1 behavior before claiming current compiler support.

Phase 18: Freeze exp-2 Collections Alpha

Define exp-2 as experimental maturity and not beta.
Specify only one concrete vector type, (vec i32), as the collections alpha source type.
Specify only compiler-known std.vec.i32.empty, std.vec.i32.append, std.vec.i32.len, and std.vec.i32.index.
Require std.vec.i32.append to return a new immutable runtime-owned vector without mutating its input.
Require (vec i32) locals, parameters, returns, calls, top-level tests, and vector equality with =.
Define allocation and index runtime trap texts.
Keep generic vectors, other element types, vector mutation, vector var/set, vector literals beyond empty/append construction, push, nested vectors, vectors in arrays/structs/options/results, iterators, slices, maps, sets, user deallocation, stable ABI/layout/helper symbols, packages, and IO expansion deferred.
Implement and gate the matching Glagol exp-2 behavior before claiming current compiler support.

Phase 19: Freeze exp-3 Standard IO And Host Environment

Define exp-3 as experimental maturity and not beta.
Specify only six compiler-known host operations: std.io.eprint, std.process.argc, std.process.arg, std.env.get, std.fs.read_text, and std.fs.write_text.
Define std.process.arg out-of-range and std.fs.read_text host read failure as exact runtime traps for this stage.
Define missing environment variables as the empty string for this stage.
Define std.fs.write_text status as 0 on success and 1 on host failure for this stage.
Keep networking, async IO, binary file APIs, directory traversal, terminal control, platform abstraction, general host error ADTs, result string Error, package interaction, stdin full read/line iteration, randomness/time, and stable ABI/layout/helper symbols deferred.
Implement and gate the matching Glagol exp-3 behavior before claiming current compiler support.

Phase 20: Freeze exp-4 User Data Types And Polymorphism

Define exp-4 as experimental maturity and not beta.
Specify only payloadless user-defined enums: (enum Name VariantA VariantB ...).
Require at least one variant per enum declaration.
Require zero-argument qualified constructors such as (Name.VariantA).
Allow enum values through immutable locals, parameters, returns, calls, same-enum equality, and top-level tests.
Define exhaustive enum match with payloadless qualified variant arms, one-or-more expression bodies, and common final result types.
Keep runtime/backend enum representation compiler-owned, with no stable layout, discriminant value, ABI, helper-symbol, reflection, or conversion-to-i32 promise.
Defer payload variants, tuple/record variants, generic enums, generic functions, type aliases, traits/interfaces/protocols, methods, derives, variant payload binding, wildcard/rest patterns, guards, nested patterns, enum values in arrays/options/results/vectors or nested structs beyond exp-18 direct fields, enum mutation, enum printing/ordering/hash, reflection, explicit discriminants, constructors with arguments, unqualified variant constructors, stable ABI/layout, and moving option/result to ordinary standard-library types.
Implement and gate the matching Glagol exp-4 behavior before claiming current compiler support.
Freeze exp-20 as F64 Numeric Primitive Alpha: promote only direct f64 value flow, decimal f64 literals, same-type f64 arithmetic/comparison, std.io.print_f64, byte-identical supported/formatter fixtures, and defer f32, wider/common integer types, char/bytes/decimal, casts, mixed numeric arithmetic, f64 containers, f64 enum payloads, f64 struct fields, parsing, random floats, stable ABI/layout, manifest schema changes, and beta maturity.

Deferred

These are future beta targets, not unresolved experimental release decisions.

Package/dependency management.
Build profiles, optimization flags, target triples, and cross-compilation.
Stable object/library/header output and broad C FFI beyond exp-6 scalar imports alpha.
Stdin formatting, recursive directory formatting, and dependency/package formatting.
Project-wide test expansion beyond the existing baseline, event streams, and stable public benchmarks. exp-9 may require benchmark fixtures or documented benchmark smoke only.
Editor integrations, LSP, SARIF, watch mode, and daemon protocols.
Macros.
Generics.
Concurrency beyond the exp-8 host time/sleep alpha target.
Advanced ownership or affine resources.
String concatenation beyond exp-1 std.string.concat, indexing, slicing, mutable string locals, string containers, user-visible string allocation or deallocation, and stable string ABI/layout.
Package manager.
Full standard library beyond the v1.5 standard-runtime alpha.
Direct x86/ARM backend.
Struct field/value mutation.
Option/result mapping, equality, printing, payloads and extraction beyond the explicitly promoted concrete result slices, nesting, containers, generic payloads, user-defined payload ADTs, and user-catchable exceptions.
Unit printing and broader standard-runtime printing.
Host IO beyond exp-3 and the exp-10 *_result slice, networking, async IO, binary file APIs, directory traversal, terminal control, platform abstraction, general host error ADTs, stdin full read/line iteration, time beyond the exp-8 host time/sleep target, randomness beyond the exp-11 target, vectors/collections beyond the current concrete (vec i32) and (vec i64) slices, user-defined standard modules, overloading, and generic standard-library APIs.
Generic vectors, vector element families beyond the current concrete i32 and i64 slices, vector mutation, vector literals beyond empty/append construction, nested vectors, vectors in arrays/structs/options/results, iterators, slices, maps, sets, user deallocation, and stable vector ABI/layout/helper symbols.
User-declared or stored unit values.
Pointer types, raw memory operations, unchecked indexing, and broad FFI beyond exp-6 scalar imports alpha.
Stable ABI and stable layout promises.

167 KiB Raw Blame History