sanjin 98f81d2d59 Release 1.0.0-beta.19 test discovery foundation

2026-05-23 01:02:00 +02:00

195 KiB

Raw Permalink Blame History

Glagol Release Notes

Summary

Glagol 1.0.0-beta.2 contains the first runtime/resource foundation slice:

Glagol recognizes std.fs.open_text_read_result, std.fs.read_open_text_result, std.fs.close_result, std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, and std.fs.create_dir_result
LLVM lowering maps those calls to private hosted runtime symbols while preserving the existing concrete result layouts
the test runner mirrors the hosted runtime policy for open/read/close file handles, status checks, file removal, and single-directory creation
focused tests cover test-runner behavior, private lowering shape, hosted native execution, diagnostics, and the explicit std.fs source facade

This is still a beta resource foundation only. It does not claim stable descriptor identity, writable streams, binary IO, directory handles, directory enumeration, sockets, async resources, rich host errors, or a stable runtime ABI.

1.0.0-beta.1

Release label: 1.0.0-beta.1

Release date: 2026-05-22

Release state: first post-beta tooling hardening release

Summary

Glagol 1.0.0-beta.1 keeps the 1.0.0-beta language/compiler support baseline and releases the first tooling-hardening slice:

glagol run <file.slo|project> compiles through the existing hosted native build path, runs the produced executable, forwards stdout/stderr, and returns the program exit status
glagol clean <file.slo|project> removes generated .slovo/build artifacts
glagol new --template binary|library|workspace adds library and local workspace scaffolds beside the existing binary default
scripts/install.sh installs bin/glagol, share/slovo/std, and share/slovo/runtime/runtime.c
installed native builds discover the runtime C input relative to the executable, with SLOVO_RUNTIME_C and GLAGOL_RUNTIME_C overrides
the release gate prints a concise final success summary

Explicit Deferrals

This is a toolchain workflow slice only. It does not claim new source syntax, a new stable ABI, a runtime resource model, networking surface, or package registry.

1.0.0-beta

Release label: 1.0.0-beta

Release date: 2026-05-21

Release state: first real general-purpose beta toolchain release

Summary

Glagol 1.0.0-beta integrates the completed unsigned u32 / u64 compiler and stdlib breadth scope with the already promoted project/package workflow, explicit std-source imports, concrete vector families, fixed arrays, structs, enums, result/option, JSON diagnostics, formatter modes, generated docs, and the paired local release gate.

The normative Glagol beta gate is .llm/V1_0_0_BETA_RELEASE_GATE.md. The beta workflow proof lives in compiler/tests/beta_1_0_0.rs.

Explicit Deferrals

No generics, no maps/sets, no remote registries, no networking/async runtime surface, and no stable ABI/layout guarantees are included by beta.

exp-125

Release label: exp-125

Release date: 2026-05-21

Release state: completed experimental precursor scope absorbed into 1.0.0-beta

Summary

exp-125 completed the connected unsigned u32 / u64 compiler and stdlib breadth scope that directly enabled 1.0.0-beta.

exp-123

exp-124

Release label: exp-124

Release date: 2026-05-21

Release state: gated experimental fixed-array enum-and-struct-elements compiler slice

Summary

Glagol exp-124 gates one connected compiler broadening: fixed immutable arrays now support direct known enum elements and current known non-recursive struct elements alongside the earlier direct scalar and string lanes.

The release updates checker admission, formatter array rendering, LLVM fixed-array typing for named element layouts, test-runner array values, machine-diagnostic snapshots, promoted array-enum and array-struct-elements fixtures and lowering snapshots, focused Glagol tests, llvm_smoke/lowering_inspector inventories, and promotion-gate alignment.

Explicit Deferrals

No zero-length arrays, no mutable arrays, no element mutation, no array equality, no array printing, no nested arrays, no slices or generics, no stable ABI/layout guarantees, and no beta maturity are included.

exp-123

Release label: exp-123

Release date: 2026-05-21

Release state: gated experimental owned-vector benchmark-suite extension and whitepaper refresh

Summary

Glagol exp-123 gates one connected benchmark/publication broadening: the local benchmark scaffold inventory now includes vec-i32-index-loop and vec-string-eq-loop beside math-loop, branch-loop, parse-loop, array-index-loop, string-eq-loop, array-struct-field-loop, and enum-struct-payload-loop.

The release keeps the shared runner model intact, adds the two new scaffold directories with Slovo/C/Rust/Python/Clojure/Common Lisp implementations, extends the focused benchmark scaffold test and promotion-gate inventory from seven kernels to nine, reruns local benchmark evidence, and refreshes the Glagol whitepaper/publication docs around the expanded suite and the current experimental compiler surface through exp-121.

Explicit Deferrals

No language-surface change, no compiler/runtime widening, no runtime ABI claim, no benchmark thresholds, no cross-machine performance claims, no broad optimizer guarantees, no PDF pipeline redesign, and no beta maturity are included.

exp-122

Release label: exp-122

Release date: 2026-05-21

Release state: gated experimental composite-data benchmark-suite extension and whitepaper refresh

Summary

Summary

Glagol exp-119 gates one connected benchmark/publication broadening: the local benchmark scaffold inventory now includes array-index-loop and string-eq-loop beside the existing math-loop, branch-loop, and parse-loop kernels.

The release keeps the shared runner model intact, adds the two new scaffold directories with Slovo/C/Rust/Python/Clojure/Common Lisp implementations, extends the focused benchmark scaffold test and promotion-gate inventory, and refreshes the Glagol whitepaper/publication docs around the expanded suite and the current experimental compiler surface.

No mutable bool locals, no new parser forms, no new compiler-known runtime names, no broader local-mutation semantics, no stable ABI/layout guarantees, and no beta maturity are included.

exp-111

Release label: exp-111

Release date: 2026-05-21

Release state: gated experimental io stdin-helper stdlib gate

Summary

Glagol exp-111 gates one connected broadening of the existing std.io helper lane.

The release keeps the already promoted compiler/runtime semantics unchanged and instead broadens the existing local and explicit-source std.io fixtures, the focused source-helper/source-search tests, and the promotion-gate inventory with:

read_stdin_result
read_stdin_option
read_stdin_or
read_stdin_i32_result
read_stdin_i32_option
read_stdin_i32_or_zero
read_stdin_i32_or
read_stdin_i64_result
read_stdin_i64_option
read_stdin_i64_or_zero
read_stdin_i64_or
read_stdin_f64_result
read_stdin_f64_option
read_stdin_f64_or_zero
read_stdin_f64_or
read_stdin_bool_result
read_stdin_bool_option
read_stdin_bool_or_false
read_stdin_bool_or

The helper lane stays source-authored over the already promoted std.io.read_stdin_result, the released std.string.parse_*_result helpers, and the exp-109 ok_or_none_* bridge helpers. The Glagol local fixture adds explicit local result.slo and string.slo bridge modules so the widened io facade remains ordinary source composition rather than new compiler-known runtime names.

Explicit Deferrals

No parser/checker/backend/runtime widening, no new compiler-known std.* runtime names, no trap-based std.io.read_stdin, no line/read-line or prompt APIs, no terminal mode, no binary/streaming/async stdin, no automatic std imports, no stable ABI/layout guarantees, and no beta maturity are included.

exp-110

Release label: exp-110

Release date: 2026-05-21

Release state: gated experimental string/env/fs/process/cli option-helper stdlib gate

Summary

Glagol exp-110 gates one connected broadening of the existing std.string, std.env, std.fs, std.process, and std.cli helper lanes.

The release keeps the already promoted compiler/runtime semantics unchanged and instead broadens the existing local and explicit-source fixtures, the focused source-helper/source-search tests, and the promotion-gate inventory with:

parse_i32_option
parse_i64_option
parse_f64_option
parse_bool_option
get_option
get_i32_option
get_i64_option
get_f64_option
get_bool_option
read_text_option
read_i32_option
read_i64_option
read_f64_option
read_bool_option
arg_option
arg_i32_option
arg_i64_option
arg_f64_option
arg_bool_option
arg_text_option
arg_i32_option
arg_i64_option
arg_f64_option
arg_bool_option

The helper lanes stay source-authored over the already promoted concrete result families plus the exp-109 ok_or_none_* bridge helpers. The Glagol local fixtures add explicit local result.slo bridge modules so the option helpers remain ordinary source composition rather than new compiler-known runtime names.

Explicit Deferrals

No parser/checker/backend/runtime widening, no new compiler-known std.* runtime names, no stdin helpers, no vec work, no automatic std imports, no stable ABI/layout guarantees, and no beta maturity are included.

exp-109

Release label: exp-109

Release date: 2026-05-21

Release state: gated experimental option/result bridge stdlib gate

Summary

Glagol exp-109 gates one connected broadening of the existing std.option and std.result helper lanes.

The release keeps the already promoted concrete option/result semantics unchanged and instead broadens the local std-layout-local-option/ and std-layout-local-result/ fixtures, the explicit std-import-option/ and std-import-result/ fixtures, the workspace std-import-option/ fixture, the focused source-helper/source-search tests, and the promotion-gate inventory with:

some_or_err_i32
some_or_err_i64
some_or_err_f64
some_or_err_bool
some_or_err_string
ok_or_none_i32
ok_or_none_i64
ok_or_none_string
ok_or_none_f64
ok_or_none_bool

The helper lanes stay concrete and source-authored over the already promoted option/result forms. std.option uses raw ok and err constructors directly, and std.result uses raw some and none constructors directly, without introducing local bridge shim modules, new compiler-known std.option.* or std.result.* runtime names, or compiler/runtime widening.

Explicit Deferrals

No new compiler-known std.* runtime names, no generics, no broader map/and_then/transpose/flatten package, no new payload families, no automatic or compiler-loaded std imports, no stable ABI/layout guarantees, and no beta maturity are included.

exp-108

Release label: exp-108

Release date: 2026-05-21

Release state: gated experimental vec-string/vec-f64/vec-bool prefix/suffix stdlib gate

Summary

Glagol exp-108 gates one connected broadening of the existing vec-string, vec-f64, and vec-bool helper lanes.

The release keeps the already promoted concrete (vec string), (vec f64), and (vec bool) compiler/runtime semantics unchanged and instead broadens the local std-layout-local-vec_string/, std-layout-local-vec_f64/, and std-layout-local-vec_bool/ fixtures, the explicit std-import-vec_string/, std-import-vec_f64/, and std-import-vec_bool/ fixtures, the focused source-helper/source-search tests, and the promotion-gate inventory with:

starts_with
without_prefix
ends_with
without_suffix

The helper lanes stay recursive and immutable with no var or set, stay concrete to the three existing vec families, and reuse only the already promoted runtime names:

std.vec.string.empty
std.vec.string.append
std.vec.string.len
std.vec.string.index
std.vec.f64.empty
std.vec.f64.append
std.vec.f64.len
std.vec.f64.index
std.vec.bool.empty
std.vec.bool.append
std.vec.bool.len
std.vec.bool.index

Explicit Deferrals

No new compiler-known std.* runtime names, no generics, no sorting, mapping, filtering, no nested/container vecs, no mutating or capacity APIs, no stable ABI/layout guarantees, and no beta maturity are included.

exp-107

Release label: exp-107

Release date: 2026-05-21

Release state: gated experimental vec-string/vec-f64/vec-bool edit-helper stdlib gate

Summary

Glagol exp-107 gates one connected broadening of the existing vec-string, vec-f64, and vec-bool helper lanes.

insert_at
insert_range
replace_at
replace_range
remove_at
remove_range

The helper lanes stay recursive and immutable with no var or set, stay concrete to the three existing vec families, and reuse only the already promoted runtime names:

std.vec.string.empty
std.vec.string.append
std.vec.string.len
std.vec.string.index
std.vec.f64.empty
std.vec.f64.append
std.vec.f64.len
std.vec.f64.index
std.vec.bool.empty
std.vec.bool.append
std.vec.bool.len
std.vec.bool.index

Explicit Deferrals

No new compiler-known std.* runtime names, no generics, no prefix/suffix helpers, no sorting/mapping/filtering, no nested/container vecs, no mutating or capacity APIs, no stable ABI/layout guarantees, and no beta maturity are included.

exp-106

Release label: exp-106

Release date: 2026-05-21

Release state: gated experimental vec-f64/vec-bool option-query stdlib gate

Summary

Glagol exp-106 gates one connected broadening of the existing vec-f64 and vec-bool helper lanes.

The release keeps the already promoted concrete (vec f64) and (vec bool) compiler/runtime semantics unchanged and instead broadens the local std-layout-local-vec_f64/ and std-layout-local-vec_bool/ fixtures, the explicit std-import-vec_f64/ and std-import-vec_bool/ fixtures, the focused source-helper/source-search tests, and the promotion-gate inventory with:

index_option
first_option
last_option
index_of_option
last_index_of_option

The helper lanes stay recursive and immutable with no var or set, stay concrete to (vec f64) and (vec bool) plus the already promoted concrete option families they return, and reuse only the already promoted runtime names:

std.vec.f64.empty
std.vec.f64.append
std.vec.f64.len
std.vec.f64.index
std.vec.bool.empty
std.vec.bool.append
std.vec.bool.len
std.vec.bool.index

Explicit Deferrals

No new compiler-known std.* runtime names, no generics, no edit helpers, no nested/container vecs, no mutating or capacity APIs, no stable ABI/layout guarantees, and no beta maturity are included.

exp-105

Release label: exp-105

Release date: 2026-05-21

Release state: gated experimental vec-f64/vec-bool transform-helper stdlib gate

Summary

Glagol exp-105 gates one connected broadening of the existing vec-f64 and vec-bool helper lanes.

concat
take
drop
reverse
subvec

The helper lanes stay recursive and immutable with no var or set, stay concrete to (vec f64) and (vec bool) only, and reuse only the already promoted runtime names:

std.vec.f64.empty
std.vec.f64.append
std.vec.f64.len
std.vec.f64.index
std.vec.bool.empty
std.vec.bool.append
std.vec.bool.len
std.vec.bool.index

Explicit Deferrals

No new compiler-known std.* runtime names, no generics, no option/result helpers, no edit helpers, no nested/container vecs, no mutating or capacity APIs, no stable ABI/layout guarantees, and no beta maturity are included.

exp-104

Release label: exp-104

Release date: 2026-05-21

Release state: gated experimental vec-bool baseline compiler/runtime plus stdlib gate

Summary

Glagol exp-104 gates the first concrete (vec bool) slice.

The release extends the checker, formatter, LLVM backend, runtime, std runtime inventory, and test runner so immutable (vec bool) params, returns, locals, direct std.vec.bool.empty/append/len/index calls, and same-family vec-bool equality work end to end. It also adds the small scalar bool-equality enablement required by the source-authored helper lane. The release adds the local std-layout-local-vec_bool/ fixture, the explicit std-import-vec_bool/ fixture, focused vec-bool collections/source helper/ source search coverage, diagnostics snapshot refreshes, and promotion-gate inventory for the connected std.vec_bool helper inventory:

empty
append
len
at
singleton
append2
append3
pair
triple
is_empty
index_or
first_or
last_or
contains
count_of

The source helpers stay recursive and immutable with no var or set, stay concrete to (vec bool) only, and reuse only the already promoted std.vec.bool.empty, std.vec.bool.append, std.vec.bool.len, and std.vec.bool.index runtime names.

Explicit Deferrals

No new compiler-known std.* runtime names beyond the vec-bool family, no generics, no option-query helpers, no transform/edit helpers, no nested vecs or vecs inside other containers, no mutating or capacity APIs, no stable ABI/layout guarantees, and no beta maturity are included.

exp-103

Release label: exp-103

Release date: 2026-05-21

Release state: gated experimental vec-f64 baseline compiler/runtime plus stdlib gate

Summary

Glagol exp-103 gates the first concrete (vec f64) slice.

The release extends the checker, formatter, LLVM backend, runtime, std runtime inventory, and test runner so immutable (vec f64) params, returns, locals, direct std.vec.f64.empty/append/len/index calls, and same-family vec-f64 equality work end to end. It also adds the local std-layout-local-vec_f64/ fixture, the explicit std-import-vec_f64/ fixture, focused vec-f64 diagnostics and promotion-gate coverage, and the connected std.vec_f64 helper inventory:

empty
append
len
at
singleton
append2
append3
pair
triple
is_empty
index_or
first_or
last_or
contains
sum

The source helpers stay recursive and immutable with no var or set, stay concrete to (vec f64) only, and reuse only the already promoted std.vec.f64.empty, std.vec.f64.append, std.vec.f64.len, and std.vec.f64.index runtime names.

Explicit Deferrals

No new compiler-known std.* runtime names beyond the vec-f64 family, no generics, no option-query helpers, no transform/edit helpers, no nested vecs or vecs inside other containers, no mutating or capacity APIs, no stable ABI/layout guarantees, and no beta maturity are included.

exp-102

Release label: exp-102

Release date: 2026-05-21

Release state: gated experimental option-bool-f64 baseline compiler/runtime plus stdlib gate

Summary

Glagol exp-102 gates the concrete (option f64) and (option bool) slice.

The release extends the checker, formatter, LLVM backend, and test runner so immutable (option f64) and (option bool) params, returns, locals, direct some/none construction, is_some, is_none, unwrap_some, and source-level match payload binding work end to end. It also broadens the local std-layout-local-option/ fixture, the explicit std-import-option/ fixture, the workspace std-import-option/ fixture, focused option-result coverage, diagnostics snapshots, and promotion-gate inventory, and it stages the connected std.option f64/bool helper inventory:

some_f64
none_f64
is_some_f64
is_none_f64
unwrap_some_f64
unwrap_or_f64
some_bool
none_bool
is_some_bool
is_none_bool
unwrap_some_bool
unwrap_or_bool

The source helpers stay explicit and concrete, and the compiler/runtime slice stays concrete to (option i32), (option i64), (option f64), (option bool), and (option string).

Explicit Deferrals

No compiler-known std.option.* runtime names, no generic option helpers, no option payload families beyond i32, i64, f64, bool, and string, no nested or container option support, no stable ABI/layout guarantees, and no beta maturity are included.

exp-101

Release label: exp-101

Release date: 2026-05-21

Release state: gated experimental vec-string option/transform stdlib gate

Summary

Glagol exp-101 gates the broadened concrete (vec string) helper lane.

The release updates the local std-layout-local-vec_string/ fixture, the explicit std-import-vec_string/ fixture, focused vec-string source-helper and source-search coverage, and promotion-gate inventory with one connected helper package:

index_option
first_option
last_option
index_of_option
last_index_of_option
concat
take
drop
reverse
subvec

The source helpers stay recursive and immutable with no var or set, stay concrete to (vec string) plus raw current (option string) / (option i32) forms only, and reuse only the already promoted std.vec.string.empty, std.vec.string.append, std.vec.string.len, and std.vec.string.index runtime names.

Explicit Deferrals

No new compiler-known std.* runtime names, no generics, no edit helpers, no prefix/suffix helpers, no nested vecs or vecs inside other containers, no mutating or capacity APIs, no stable ABI/layout guarantees, and no beta maturity are included.

exp-100

Release label: exp-100

Release date: 2026-05-21

Release state: gated experimental option-string baseline compiler/runtime plus stdlib gate

Summary

Glagol exp-100 gates the first concrete (option string) slice.

The release extends the checker, formatter, LLVM backend, and test runner so immutable (option string) params, returns, locals, direct some/none construction, is_some, is_none, unwrap_some, and source-level match payload binding work end to end. It also broadens the local std-layout-local-option/ fixture, the explicit std-import-option/ fixture, the workspace std-import-option/ fixture, focused option/result coverage, and promotion-gate inventory, and it stages the connected std.option string helper inventory:

some_string
none_string
is_some_string
is_none_string
unwrap_some_string
unwrap_or_string

The source helpers stay explicit and concrete, and the compiler/runtime slice stays concrete to (option i32), (option i64), and (option string).

Explicit Deferrals

No compiler-known std.option.* runtime names, no generic option helpers, no option payload families beyond i32, i64, and string, no nested or container option support, no stable ABI/layout guarantees, and no beta maturity are included.

exp-99

Release label: exp-99

Release date: 2026-05-21

Release state: gated experimental vec-string baseline compiler/runtime plus stdlib gate

Summary

Glagol exp-99 gates the first concrete (vec string) slice.

The release extends the checker, formatter, LLVM backend, runtime, std runtime inventory, and test runner so immutable (vec string) params, returns, locals, direct std.vec.string.empty, std.vec.string.append, std.vec.string.len, std.vec.string.index, and concrete vec-string equality work end to end. It also adds examples/vec-string.slo, adds the local std-layout-local-vec_string/ fixture, adds the explicit std-import-vec_string/ fixture, adds focused diagnostics and promotion-gate coverage, and stages the frozen std.vec_string helper inventory:

empty
append
len
at
singleton
append2
append3
pair
triple
is_empty
index_or
first_or
last_or
contains
count_of

The source helpers stay recursive and immutable with no var or set, use only the promoted std.vec.string runtime names, and keep real-program coverage focused on contains and count_of.

In Glagol-only repo states, the explicit-source std-import-vec_string/ fixture now remains authored and format-checked even if sibling lib/std/vec_string.slo has not landed yet; the full check/test lane for that fixture still depends on the paired Slovo source file.

Explicit Deferrals

No generics, no other vec element families, no option-query helpers, no transform/range/edit helpers, no nested vecs or vecs inside other containers, no mutating or capacity APIs, no stable ABI/layout guarantees, and no beta maturity are included.

exp-98

Release label: exp-98

Release date: 2026-05-21

Release state: gated experimental vec-i64-edit-helper stdlib gate

Summary

Glagol exp-98 gates the concrete edit-helper extension for the staged std.vec_i64 source-authored facade.

The release updates the local std-layout-local-vec_i64/ fixture, updates the explicit std-import-vec_i64/ fixture against repo-root lib/std/vec_i64.slo, adds focused integration coverage, and extends promotion-gate inventory and sibling Slovo alignment checks for these helpers:

insert_at
insert_range
replace_at
replace_range
remove_at
remove_range

The helpers reuse only the existing std.vec.i64 runtime family plus the already promoted (option i32) and (option i64) surface. insert_at(values,position,value) inserts before position, appends when position == len(values), and otherwise leaves out-of-range inputs unchanged. insert_range(values,position,inserted) follows the same position rules while preserving left-to-right order of both vectors. replace_at and remove_at leave negative and out-of-range positions unchanged. The range helpers leave values unchanged for negative starts, degenerate or reversed ranges, and start >= len(values); overlong end_exclusive values edit through the tail; and valid edits preserve element order while leaving source vectors unchanged. The local Glagol-owned fixture stays source-authored, recursive, and immutable without var or set, and the release adds no new parser, checker, runtime, formatter, or LLVM semantics.

Explicit Deferrals

No generic vectors, no new compiler-known std.* runtime names, no automatic standard-library imports, no compiler-loaded std source, no mutable vector APIs, no capacity/reserve management, no iterators, sorting, mapping, filtering, stable ABI/layout guarantees, or beta maturity are included.

exp-97

Release label: exp-97

Release date: 2026-05-21

Release state: gated experimental vec-i64-transform-helper stdlib gate

Summary

Glagol exp-97 gates the concrete transform-helper extension for the staged std.vec_i64 source-authored facade.

concat
take
drop
reverse
subvec

The helpers reuse only the existing std.vec.i64 runtime family plus the already promoted (option i32) and (option i64) surface. concat(left,right) preserves left-to-right element order, take(values,count) treats negative counts as zero and saturates to the full vector, drop(values,count) treats negative counts as zero and saturates to the empty vector, reverse(values) returns a new vector in reverse order, and subvec(values,start,end_exclusive) returns the bounded middle slice while using the same concrete vec_i64 lane. The local Glagol-owned fixture stays source-authored, recursive, and immutable without var or set, and the release adds no new parser, checker, runtime, formatter, or LLVM semantics.

Explicit Deferrals

No vec_i64 insert/replace/remove helpers, no generics, no new compiler-known std.* runtime names, no mutating vector or capacity APIs, no iterators, sorting, mapping, filtering, stable ABI/layout guarantees, or beta maturity are included.

exp-96

Release label: exp-96

Release date: 2026-05-20

Release state: gated experimental vec-i64-option-query-helper stdlib gate

Summary

Glagol exp-96 gates the concrete option-query helper extension for the staged std.vec_i64 source-authored facade.

index_option
first_option
last_option
index_of_option
last_index_of_option

The helpers reuse only the existing std.vec.i64 runtime family plus the already promoted (option i32) and (option i64) surface. index_option(values,position), first_option(values), and last_option(values) return concrete (option i64) observations of vec elements; index_of_option(values,target) and last_index_of_option(values,target) return concrete (option i32) position results. The local Glagol-owned fixture stays source-authored, recursive, and immutable without var or set, and the release adds no new parser, checker, runtime, formatter, or LLVM semantics.

Explicit Deferrals

No vec_i64 transform/range/edit helpers, no generics, no new compiler-known std.* runtime names, no mutating vector or capacity APIs, no iterators, sorting, mapping, filtering, stable ABI/layout guarantees, or beta maturity are included.

exp-95

Release label: exp-95

Release date: 2026-05-20

Release state: gated experimental option-i64-baseline compiler/runtime and stdlib gate

Summary

Glagol exp-95 gates the first concrete (option i64) baseline across the compiler, local source fixtures, and explicit-source std.option import path.

The release broadens the checker, formatter, LLVM backend, and test runner so immutable (option i64) params, returns, locals, some, none, is_some, is_none, unwrap_some, and source-level match payload bindings work end to end. It adds the local std-layout-local-option/ i64 helper coverage, widens the explicit std-import-option/ project against repo-root lib/std/option.slo, extends diagnostics snapshots and promotion-gate inventory, and broadens the staged helper surface with:

some_i64
none_i64
is_some_i64
is_none_i64
unwrap_some_i64
unwrap_or_i64

Explicit Deferrals

No compiler-known std.option.* runtime names, no generic option helpers, no option payload families beyond i32 and i64, no nested/container option support, no option equality or printing, no stable ABI/layout guarantee, no manifest schema changes, and no beta maturity are included.

exp-94

Release label: exp-94

Release date: 2026-05-20

Release state: gated experimental vec-i64-baseline compiler/runtime and stdlib gate

Summary

Glagol exp-94 gates the concrete (vec i64) runtime and compiler surface plus the first local and explicit-source std.vec_i64 facade baseline.

The release promotes std.vec.i64.empty, std.vec.i64.append, std.vec.i64.len, and std.vec.i64.index; adds (vec i64) equality; extends the checker, formatter, lowering, LLVM backend, runtime, test runner, and runtime catalog for concrete (vec i64) values; adds the local std-layout-local-vec_i64/ fixture; adds the explicit std-import-vec_i64/ fixture against repo-root lib/std/vec_i64.slo; adds focused integration coverage; and extends promotion-gate inventory for this connected baseline:

empty
append
len
at
singleton
append2
append3
pair
triple
is_empty
index_or
first_or
last_or
contains
sum

The source surface stays concrete to (vec i64) and immutable. It reuses only the promoted std.vec.i64 runtime names, leaves source vectors unchanged, and does not widen option/result payload families or introduce generic vector semantics.

Explicit Deferrals

No generic vectors, no vector payload families beyond the concrete (vec i32) and (vec i64) slices, no automatic standard-library imports, no edits under slovo/**, no compiler-loaded std source beyond the existing explicit search rules, no new compiler-known std.* runtime names beyond std.vec.i64.*, no slice or view types, no mutable vector locals, no mutating vector APIs, no option/result payload widening, no vector families for f64, string, or bool, no capacity or reserve management, no sorting, mapping, filtering, or iterator APIs, no stable ABI/layout guarantees, and no beta maturity are included.

exp-93

Release label: exp-93

Release date: 2026-05-20

Release state: gated experimental vec-i32-count-of-helper stdlib gate

Summary

Glagol exp-93 gates the concrete count-of helper extension for the staged std.vec_i32 source-authored facade.

The release updates the explicit std-import-vec_i32/ project, updates the local source-authored std-layout-local-vec_i32/ fixture, adds focused integration coverage, and extends promotion-gate inventory and sibling Slovo alignment checks for this helper:

count_of

The helper is an ordinary source-authored composition over the existing promoted std.vec.i32 runtime family and the already staged std.vec_i32 wrappers for len and at, plus equality and while. count_of(values,target) returns the number of elements of values equal to target; returns 0 for empty and no-match cases; counts repeated matches exactly; leaves the source vector unchanged; and adds no new parser, checker, runtime, formatter, or LLVM semantics for this release.

Explicit Deferrals

No generic vectors, no vector payload families beyond (vec i32), no automatic standard-library imports, no compiler-loaded std source, no new compiler-known std.* runtime names, no new private recursive helper loops, no broader aggregation/filter families beyond the current concrete vec surface, no slice or view types, no mutable (vec i32) local support, no capacity or reserve management, no sorting, mapping, filtering, or iterator APIs, no stable ABI/layout guarantees, and no beta maturity are included.

exp-92

Release label: exp-92

Release date: 2026-05-20

Release state: gated experimental vec-i32-without-prefix-helper stdlib gate

Summary

Glagol exp-92 gates the concrete without-prefix helper extension for the staged std.vec_i32 source-authored facade.

without_prefix

The helper is an ordinary source-authored composition over the existing promoted std.vec.i32 runtime family and the already staged std.vec_i32 wrappers for empty, append, len, and at, plus the already staged source helpers starts_with, drop, and len. without_prefix(values,prefix) removes a matching leading prefix from values; returns values unchanged for empty, longer, or mismatched prefixes; returns (empty) for an exact match; preserves the order of the remaining suffix; leaves both source vectors unchanged; and adds no new parser, checker, runtime, formatter, or LLVM semantics for this release.

Explicit Deferrals

No generic vectors, no vector payload families beyond (vec i32), no automatic standard-library imports, no compiler-loaded std source, no new compiler-known std.* runtime names, no new private recursive helper loops, no broader prefix/suffix helper families beyond the current starts_with, without_prefix, ends_with, and without_suffix helpers, no slice or view types, no mutable (vec i32) local support, no capacity or reserve management, no sorting, mapping, filtering, or iterator APIs, no stable ABI/layout guarantees, and no beta maturity are included.

exp-91

Release label: exp-91

Release date: 2026-05-20

Release state: gated experimental vec-i32-without-suffix-helper stdlib gate

Summary

Glagol exp-91 gates the concrete without-suffix helper extension for the staged std.vec_i32 source-authored facade.

without_suffix

The helper is an ordinary source-authored composition over the existing promoted std.vec.i32 runtime family and the already staged std.vec_i32 wrappers for empty, append, len, and at, plus the already staged source helpers ends_with, take, and len. without_suffix(values,suffix) removes a matching trailing suffix from values; returns values unchanged for empty, longer, or mismatched suffixes; returns (empty) for an exact match; preserves the order of the remaining prefix; leaves both source vectors unchanged; and adds no new parser, checker, runtime, formatter, or LLVM semantics for this release.

Explicit Deferrals

No generic vectors, no vector payload families beyond (vec i32), no automatic standard-library imports, no compiler-loaded std source, no new compiler-known std.* runtime names, no new private recursive helper loops, no broader prefix/suffix helper families beyond the current starts_with, ends_with, and without_suffix helpers, no slice or view types, no mutable (vec i32) local support, no capacity or reserve management, no sorting, mapping, filtering, or iterator APIs, no stable ABI/layout guarantees, and no beta maturity are included.

exp-90

Release label: exp-90

Release date: 2026-05-20

Release state: gated experimental vec-i32-ends-with-helper stdlib gate

Summary

Glagol exp-90 gates the concrete ends-with helper extension for the staged std.vec_i32 source-authored facade.

ends_with

The helper is an ordinary source-authored composition over the existing promoted std.vec.i32 runtime family and the already staged std.vec_i32 wrappers for empty, append, len, and at, plus the already staged source helpers drop and vec equality. ends_with(values,suffix) returns true exactly when values ends with all elements of suffix in order; returns true for an empty suffix; returns false when len(suffix) > len(values); returns true for equal vectors and shorter matching suffixes; returns false for mismatched suffixes; leaves both source vectors unchanged; and adds no new parser, checker, runtime, formatter, or LLVM semantics for this release.

Explicit Deferrals

No generic vectors, no vector payload families beyond (vec i32), no automatic standard-library imports, no compiler-loaded std source, no new compiler-known std.* runtime names, no new private recursive helper loops, no broader prefix/suffix query families beyond the current starts_with and ends_with helpers, no slice or view types, no mutable (vec i32) local support, no capacity or reserve management, no sorting, mapping, filtering, or iterator APIs, no stable ABI/layout guarantees, and no beta maturity are included.

exp-89

Release label: exp-89

Release date: 2026-05-20

Release state: gated experimental vec-i32-starts-with-helper stdlib gate

Summary

Glagol exp-89 gates the concrete starts-with helper extension for the staged std.vec_i32 source-authored facade.

starts_with

The helper is an ordinary source-authored composition over the existing promoted std.vec.i32 runtime family and the already staged std.vec_i32 wrappers for empty, append, len, and at, plus the already staged source helpers take and vec equality. starts_with(values,prefix) returns true exactly when values begins with all elements of prefix in order; returns true for an empty prefix; returns false when len(prefix) > len(values); returns true for equal vectors and shorter matching prefixes; returns false for mismatched prefixes; leaves both source vectors unchanged; and adds no new parser, checker, runtime, formatter, or LLVM semantics for this release.

Explicit Deferrals

No generic vectors, no vector payload families beyond (vec i32), no automatic standard-library imports, no compiler-loaded std source, no new compiler-known std.* runtime names, no new private recursive helper loops, no broader prefix/suffix query families beyond this single helper, no slice or view types, no mutable (vec i32) local support, no capacity or reserve management, no sorting, mapping, filtering, or iterator APIs, no stable ABI/layout guarantees, and no beta maturity are included.

exp-88

Release label: exp-88

Release date: 2026-05-20

Release state: gated experimental vec-i32-replace-range-helper stdlib gate

Summary

Glagol exp-88 gates the concrete replace-range helper extension for the staged std.vec_i32 source-authored facade.

replace_range

The helper is an ordinary source-authored composition over the existing promoted std.vec.i32 runtime family and the already staged std.vec_i32 wrappers for empty, append, len, and at, plus the already staged source helpers take, drop, and concat. replace_range(values,start,end_exclusive,replacement) returns values unchanged when start < 0, when end_exclusive <= start, or when start >= len(values); replaces the half-open range [start, end_exclusive) when both bounds are in range; replaces the tail from start when end_exclusive >= len(values); preserves the order of both vectors; leaves both source vector values unchanged; and adds no new parser, checker, runtime, formatter, or LLVM semantics for this release.

Explicit Deferrals

No generic vectors, no vector payload families beyond (vec i32), no automatic standard-library imports, no compiler-loaded std source, no new compiler-known std.* runtime names, no new private recursive helper loops, no bulk-edit APIs beyond this single contiguous replacement helper, no slice or view types, no mutable (vec i32) local support, no capacity or reserve management, no sorting, mapping, filtering, or iterator APIs, no stable ABI/layout guarantees, and no beta maturity are included.

exp-87

Release label: exp-87

Release date: 2026-05-20

Release state: gated experimental vec-i32-insert-range-helper stdlib gate

Summary

Glagol exp-87 gates the concrete insert-range helper extension for the staged std.vec_i32 source-authored facade.

insert_range

The helper is an ordinary source-authored composition over the existing promoted std.vec.i32 runtime family and the already staged std.vec_i32 wrappers for empty, append, len, and at, plus the already staged source helpers take, drop, and concat. insert_range(values,position,inserted) returns values unchanged when position < 0 or position > len(values); inserts inserted before the current element when 0 <= position < len(values); appends inserted when position == len(values); preserves the order of both vectors; leaves both source vector values unchanged; and adds no new parser, checker, runtime, formatter, or LLVM semantics for this release.

Explicit Deferrals

No generic vectors, no vector payload families beyond (vec i32), no automatic standard-library imports, no compiler-loaded std source, no new compiler-known std.* runtime names, no new private recursive helper loops, no bulk-edit APIs beyond this single contiguous range insertion helper, no multi-position insertion helpers, no mutable (vec i32) local support, no capacity or reserve management, no sorting, mapping, filtering, or iterator APIs, no stable ABI/layout guarantees, and no beta maturity are included.

exp-86

Release label: exp-86

Release date: 2026-05-20

Release state: gated experimental vec-i32-remove-range-helper stdlib gate

Summary

Glagol exp-86 gates the concrete remove-range helper extension for the staged std.vec_i32 source-authored facade.

remove_range

The helper is an ordinary source-authored composition over the existing promoted std.vec.i32 runtime family and the already staged std.vec_i32 wrappers for empty, append, len, and at, plus the already staged source helpers take, drop, and concat. remove_range(values,start,end_exclusive) returns values unchanged when start < 0, when end_exclusive <= start, or when start >= len(values); returns the prefix before start when end_exclusive >= len(values); otherwise returns a new vector with the half-open range [start, end_exclusive) removed, preserves the order of the remaining elements, and leaves the source vector value unchanged. Glagol adds no new parser, checker, runtime, formatter, or LLVM semantics for this release.

Explicit Deferrals

No generic vectors, no vector payload families beyond (vec i32), no automatic standard-library imports, no compiler-loaded std source, no new compiler-known std.* runtime names, no new private recursive helper loops, no bulk-edit APIs beyond this single contiguous removal helper, no mutable (vec i32) local support, no capacity or reserve management, no sorting, mapping, filtering, or iterator APIs, no stable ABI/layout guarantees, and no beta maturity are included.

exp-85

Release label: exp-85

Release date: 2026-05-20

Release state: gated experimental vec-i32-subvec-helper stdlib gate

Summary

Glagol exp-85 gates the concrete subvector-helper extension for the staged std.vec_i32 source-authored facade.

subvec

The helper is an ordinary source-authored composition over the existing promoted std.vec.i32 runtime family and the already staged std.vec_i32 wrappers for empty, append, len, and at, plus the already staged source helpers drop and take. subvec(values,start,end_exclusive) returns the empty vector when start < 0, when end_exclusive <= start, or when start >= len(values); returns the remaining tail from start when end_exclusive > len(values); otherwise returns a copied contiguous subvector [start, end_exclusive) with preserved left-to-right order; and leaves the source vector value unchanged. Glagol adds no new parser, checker, runtime, formatter, or LLVM semantics for this release.

Explicit Deferrals

No generic vectors, no vector payload families beyond (vec i32), no automatic standard-library imports, no compiler-loaded std source, no new compiler-known std.* runtime names, no new private recursive helper loops, no slice or view types, no mutable (vec i32) local support, no capacity or reserve management, no sorting, mapping, filtering, or iterator APIs, no stable ABI/layout guarantees, and no beta maturity are included.

exp-84

Release label: exp-84

Release date: 2026-05-20

Release state: gated experimental vec-i32-insert-helper stdlib gate

Summary

Glagol exp-84 gates the concrete insert-helper extension for the staged std.vec_i32 source-authored facade.

insert_at

The helper is an ordinary source-authored composition over the existing promoted std.vec.i32 runtime family and the already staged std.vec_i32 wrappers for empty, append, len, and at, plus the already staged source helpers take, drop, and concat. insert_at(values,position,value) returns values unchanged when position < 0 or position > len(values); inserts value before the current element when 0 <= position < len(values); appends value when position == len(values); preserves the surrounding order; increases the result length by one for valid insertions; and leaves the source vector value unchanged. Glagol adds no new parser, checker, runtime, formatter, or LLVM semantics for this release.

Explicit Deferrals

No generic vectors, no vector payload families beyond (vec i32), no automatic standard-library imports, no compiler-loaded std source, no new compiler-known std.* runtime names, no new private recursive helper loops, no bulk-edit APIs, no multi-index insertion, no mutable (vec i32) local support, no capacity or reserve management, no sorting, mapping, filtering, or iterator APIs, no stable ABI/layout guarantees, and no beta maturity are included.

exp-83

Release label: exp-83

Release date: 2026-05-20

Release state: gated experimental vec-i32-remove-helper stdlib gate

Summary

Glagol exp-83 gates the concrete remove-helper extension for the staged std.vec_i32 source-authored facade.

remove_at

The helper is an ordinary source-authored composition over the existing promoted std.vec.i32 runtime family and the already staged std.vec_i32 wrappers for empty, append, len, and at, plus the already staged source helpers take, drop, and concat. remove_at(values,position) returns values unchanged when position < 0 or position >= len(values); otherwise it returns a new vector with the element at position removed, preserves the order of the remaining elements, shortens the result length by one, and leaves the source vector value unchanged. Glagol adds no new parser, checker, runtime, formatter, or LLVM semantics for this release.

Explicit Deferrals

No generic vectors, no vector payload families beyond (vec i32), no automatic standard-library imports, no compiler-loaded std source, no new compiler-known std.* runtime names, no new private recursive helper loops, no insert helpers, no bulk-edit APIs, no multi-index removal, no mutable (vec i32) local support, no capacity or reserve management, no sorting, mapping, filtering, or iterator APIs, no stable ABI/layout guarantees, and no beta maturity are included.

exp-82

Release label: exp-82

Release date: 2026-05-20

Release state: gated experimental vec-i32-replace-helper stdlib gate

Summary

Glagol exp-82 gates the concrete replace-helper extension for the staged std.vec_i32 source-authored facade.

replace_at

The helper is an ordinary source-authored composition over the existing promoted std.vec.i32 runtime family and the already staged std.vec_i32 wrappers for empty, append, len, and at, plus the already staged source helpers take, drop, and concat. replace_at(values,position,replacement) returns values unchanged when position < 0 or position >= len(values); otherwise it returns a new vector with the same length and order except for the replaced slot. Glagol adds no new parser, checker, runtime, formatter, or LLVM semantics for this release.

Explicit Deferrals

No generic vectors, no vector payload families beyond (vec i32), no automatic standard-library imports, no compiler-loaded std source, no new compiler-known std.* runtime names, no private mutation loops, no insert or remove helpers, no bulk-edit APIs, no mutable (vec i32) local support, no capacity or reserve management, no sorting, mapping, filtering, or iterator APIs, no stable ABI/layout guarantees, and no beta maturity are included.

exp-81

Release label: exp-81

Release date: 2026-05-20

Release state: released experimental vec-i32-range-helper stdlib gate

Summary

Glagol exp-81 gates the concrete range-helper extension for the staged std.vec_i32 source-authored facade.

range

The helper is ordinary source-authored recursion over the existing promoted std.vec.i32 runtime family and the already staged std.vec_i32 wrappers for empty, append, len, and at. range(start,end_exclusive) generates the ascending half-open sequence [start, start + 1, ..., end_exclusive - 1], returns the empty vector when end_exclusive <= start, and accepts negative bounds. The recursive generation helper remains private to the fixture source. Glagol adds no new parser, checker, runtime, formatter, or LLVM semantics for this release.

Explicit Deferrals

No generic vectors, no vector payload families beyond (vec i32), no automatic standard-library imports, no compiler-loaded std source, no new compiler-known std.* runtime names, no edit helpers, no descending, stepped, or inclusive range variants, no mutable (vec i32) local support, no capacity or reserve management, no sorting, mapping, filtering, or iterator APIs, no stable ABI/layout guarantees, and no beta maturity are included.

exp-80

Release label: exp-80

Release date: 2026-05-20

Release state: released experimental vec-i32-generated-constructor-helper stdlib gate

Summary

Glagol exp-80 gates the concrete generated-constructor-helper extension for the staged std.vec_i32 source-authored facade.

repeat
range_from_zero

The helpers are ordinary source-authored recursion over the existing promoted std.vec.i32 runtime family and the already staged std.vec_i32 wrappers for empty, append, len, and at. repeat(value,count) returns the empty vector for count <= 0, and range_from_zero(count) generates the ascending half-open sequence [0, 1, ..., count - 1], returning the empty vector for count <= 0. The recursive generation helpers remain private to the fixture source. Glagol adds no new parser, checker, runtime, formatter, or LLVM semantics for this release.

Explicit Deferrals

No generic vectors, no vector payload families beyond (vec i32), no automatic standard-library imports, no compiler-loaded std source, no new compiler-known std.* runtime names, no edit helpers, no public range helper, no descending, stepped, or inclusive range variants, no mutable (vec i32) local support, no capacity or reserve management, no sorting, mapping, filtering, or iterator APIs, no stable ABI/layout guarantees, and no beta maturity are included.

exp-79

Release label: exp-79

Release date: 2026-05-20

Release state: released experimental vec-i32-transform-helper stdlib gate

Summary

Glagol exp-79 gates the concrete transform-helper extension for the staged std.vec_i32 source-authored facade.

concat
take
drop
reverse

Explicit Deferrals

No generic vectors, no vector payload families beyond (vec i32), no automatic standard-library imports, no compiler-loaded std source, no new compiler-known std.* runtime names, no mutable (vec i32) local support, no capacity or reserve management, no sorting, mapping, filtering, or iterator APIs, no stable ABI/layout guarantees, and no beta maturity are included.

exp-78

Release label: exp-78

Release date: 2026-05-20

Release state: released experimental cli-local-source-facade stdlib gate

Summary

Glagol exp-78 gates the Glagol-side local source-authored cli facade that mirrors the existing staged std.cli helper surface without widening it.

The release adds examples/projects/std-layout-local-cli/ with explicit local cli.slo, process.slo, and string.slo modules plus the matching main.slo consumer, adds focused integration coverage, and extends promotion-gate inventory/alignment checks for these helpers:

arg_text_result
arg_i32_result
arg_i32_or_zero
arg_i32_or
arg_i64_result
arg_i64_or_zero
arg_i64_or
arg_f64_result
arg_f64_or_zero
arg_f64_or
arg_bool_result
arg_bool_or_false
arg_bool_or

The local fixture stays source-authored and explicit: main.slo imports local cli, cli.slo imports local process and string, process.slo wraps only the existing promoted std.process.arg_result, and string.slo wraps only the existing promoted concrete parse-result helpers. Glagol adds no new parser, checker, runtime, formatter, or LLVM semantics for this release.

Explicit Deferrals

No widened std.cli API, no automatic standard-library imports, no compiler- loaded std source, no automatic standard-library search semantics, no new compiler-known std.* runtime names, no process spawning, exit/status control, no current-directory APIs, no signal handling, no shell parsing, no subcommands, no flag or option frameworks, no stable ABI/layout guarantees, and no beta maturity are included.

exp-77

Release label: exp-77

Release date: 2026-05-20

Release state: released experimental vec-i32-option-query-helper stdlib gate

Summary

Glagol exp-77 extends the concrete (vec i32) source-authored collection facade in the staged std.vec_i32 module with option-returning query helpers.

index_option
first_option
last_option
index_of_option
last_index_of_option

The helpers are ordinary source wrappers and loops over the existing promoted std.vec.i32 runtime family plus the existing (option i32) surface. Glagol adds no new parser, checker, runtime, or LLVM semantics for this release.

Explicit Deferrals

No generic vectors, no vector payload families beyond (vec i32), no option payload families beyond (option i32), no automatic standard-library imports, no compiler-loaded std source, no new compiler-known std.* runtime names, no capacity or reserve management, no sorting, mapping, filtering, or iterator APIs, no mutating collection APIs, no stable ABI/layout guarantees, and no beta maturity are included.

exp-76

Release label: exp-76

Release date: 2026-05-20

Release state: released experimental vec-i32-source-helper stdlib gate

Summary

Glagol exp-76 gates a concrete (vec i32) source-authored collection facade in the staged std.vec_i32 module.

The release adds the explicit std-import-vec_i32/ project, adds the local source-authored std-layout-local-vec_i32/ fixture, adds focused integration coverage, and extends promotion-gate inventory and sibling Slovo alignment checks for these helpers:

empty
append
len
at
singleton
append2
append3
pair
triple
is_empty
index_or
first_or
last_or
contains
sum

The helpers are ordinary source wrappers and loops over the existing promoted std.vec.i32 runtime family. Glagol adds no new parser, checker, runtime, or LLVM semantics for this release.

Explicit Deferrals

No generic vectors, no vector payload families beyond (vec i32), no automatic standard-library imports, no compiler-loaded std source, no new compiler-known std.* runtime names, no capacity or reserve management, no sorting, mapping, filtering, or iterator APIs, no stable ABI/layout guarantees, and no beta maturity are included.

exp-75

Release label: exp-75

Release date: 2026-05-20

Release state: released experimental option-constructor stdlib gate

Summary

Glagol exp-75 gates source-authored concrete option constructors in the staged std.option facade.

The release expands the explicit std-import-option/ project, updates the local source-authored std-layout-local-option/ fixture, and extends focused integration coverage plus promotion-gate inventory/alignment checks for these helpers:

some_i32
none_i32

The helpers are ordinary source wrappers over the existing some and none forms for the currently promoted (option i32) family. Glagol adds no new parser, checker, runtime, or LLVM semantics for this release.

Explicit Deferrals

No generic option helpers, no new option payload families, no automatic standard-library imports, no compiler-loaded std source, no new compiler-known std.* runtime names, no stable ABI/layout guarantees, and no beta maturity are included.

exp-74

Release label: exp-74

Release date: 2026-05-20

Release state: released experimental result-constructor stdlib gate

Summary

Glagol exp-74 gates source-authored concrete result constructors in the staged std.result facade.

The release expands the explicit std-import-result/ project, updates the local source-authored std-layout-local-result/ fixture, and extends focused integration coverage plus promotion-gate inventory/alignment checks for these helpers:

ok_i32
err_i32
ok_i64
err_i64
ok_string
err_string
ok_f64
err_f64
ok_bool
err_bool

The helpers are ordinary source wrappers over the existing ok and err forms for the currently promoted concrete result families. Glagol adds no new parser, checker, runtime, or LLVM semantics for this release.

Explicit Deferrals

No generic result helpers, no new result payload families, no richer error ADTs, no automatic standard-library imports, no compiler-loaded std source, no new compiler-known std.* runtime names, no stable ABI/layout guarantees, and no beta maturity are included.

exp-73

Release label: exp-73

Release date: 2026-05-20

Release state: released experimental io-value-helper stdlib gate

Summary

Glagol exp-73 gates source-authored value-returning print helpers in the staged std.io facade.

The release expands the explicit std-import-io/ project, adds the local source-authored std-layout-local-io/ fixture plus focused integration coverage, and extends promotion-gate inventory/alignment checks for these helpers:

print_i32_value
print_i64_value
print_f64_value
print_string_value
print_bool_value

The helpers are ordinary source wrappers over the existing promoted print runtime calls. Glagol adds no new parser, checker, runtime, or LLVM semantics for this release.

Explicit Deferrals

No automatic standard-library imports, no compiler-loaded std source, no stderr facade helpers, no stdin facade helpers, no line iteration, no prompt APIs, no terminal control, no binary or streaming IO, no async IO, no new compiler-known std.* runtime names, no stable ABI/layout guarantees, and no beta maturity are included.

exp-72

Release label: exp-72

Release date: 2026-05-20

Release state: released experimental cli-custom-fallback stdlib gate

Summary

Glagol exp-72 gates source-authored typed CLI argument custom-fallback helpers in the staged std.cli facade.

The release expands the explicit std-import-cli/ project, adds focused integration coverage, and extends promotion-gate inventory/alignment checks for these helpers:

arg_i32_or
arg_i64_or
arg_f64_or
arg_bool_or

The helpers are ordinary source wrappers over the existing argument lookup and concrete parse result families. Glagol adds no new parser, checker, runtime, or LLVM semantics for this release.

Explicit Deferrals

No automatic standard-library imports, no compiler-loaded std source, no process spawning, no exit/status control, no current-directory APIs, no signal handling, no shell parsing, no subcommands, no richer CLI framework APIs, no generic configuration helpers, no new compiler-known std.* runtime names, no stable ABI/layout guarantees, and no beta maturity are included.

exp-71

Release label: exp-71

Release date: 2026-05-20

Release state: released experimental process-custom-fallback stdlib gate

Summary

Glagol exp-71 gates source-authored typed process argument custom-fallback helpers in the staged std.process facade.

The release expands the local source-authored process fixture at examples/projects/std-layout-local-process/ with a local string.slo parse wrapper module, expands the explicit std-import-process/ project, adds focused integration coverage, and extends promotion-gate inventory/alignment checks for these helpers:

arg_i32_or
arg_i64_or
arg_f64_or
arg_bool_or

The helpers are ordinary source wrappers over the existing argument lookup and concrete parse result families. Glagol adds no new parser, checker, runtime, or LLVM semantics for this release.

Explicit Deferrals

exp-70

Release label: exp-70

Release date: 2026-05-20

Release state: released experimental fs-custom-fallback stdlib gate

Summary

Glagol exp-70 gates source-authored typed filesystem read custom-fallback helpers in the staged std.fs facade.

The release expands the local source-authored fs fixture at examples/projects/std-layout-local-fs/ with a local string.slo parse wrapper module, expands the explicit std-import-fs/ project, adds focused integration coverage, and extends promotion-gate inventory/alignment checks for these helpers:

read_i32_or
read_i64_or
read_f64_or
read_bool_or

The helpers are ordinary source wrappers over the existing text-read and concrete parse result families. Glagol adds no new parser, checker, runtime, or LLVM semantics for this release.

Explicit Deferrals

No automatic standard-library imports, no compiler-loaded std source, no binary file APIs, no directory traversal, no streaming file IO, no async file IO, no typed file writes, no rich host errors, no new compiler-known std.* runtime names, no stable ABI/layout guarantees, and no beta maturity are included.

exp-69

Release label: exp-69

Release date: 2026-05-20

Release state: released experimental env-custom-fallback stdlib gate

Summary

Glagol exp-69 gates source-authored typed environment parse custom-fallback helpers in the staged std.env facade.

The release expands the local source-authored env fixture at examples/projects/std-layout-local-env/, expands the explicit std-import-env/ project, adds deterministic present/missing/invalid environment setup to focused integration coverage, and extends promotion-gate inventory/alignment checks for these helpers:

get_i32_or
get_i64_or
get_f64_or
get_bool_or

The helpers are ordinary source wrappers over the existing environment lookup and concrete parse result families. Glagol adds no new parser, checker, runtime, or LLVM semantics for this release.

Explicit Deferrals

No automatic standard-library imports, no compiler-loaded std source, no generic configuration helpers, no environment mutation, no environment enumeration, no environment writes, no rich host errors, no new compiler-known std.* runtime names, no stable ABI/layout guarantees, and no beta maturity are included.

exp-68

Release label: exp-68

Release date: 2026-05-20

Release state: released experimental string-custom-fallback stdlib gate

Summary

Glagol exp-68 gates source-authored typed string parse custom-fallback helpers in the staged std.string facade.

The release expands the local source-authored string fixture at examples/projects/std-layout-local-string/, expands the explicit std-import-string/ project, adds focused integration coverage, and extends promotion-gate inventory/alignment checks for these helpers:

parse_i32_or
parse_i64_or
parse_f64_or
parse_bool_or

The helpers are ordinary source wrappers over the existing concrete parse result families. Glagol adds no new parser, checker, runtime, or LLVM semantics for this release.

Explicit Deferrals

No automatic standard-library imports, no compiler-loaded std source, no generic parse helpers, no whitespace trimming, no case-insensitive bool parsing, no rich parse errors, no new compiler-known std.* runtime names, no stable ABI/layout guarantees, and no beta maturity are included.

exp-67

Release label: exp-67

Release date: 2026-05-20

Release state: released experimental process-typed stdlib gate

Summary

Glagol exp-67 gates source-authored typed process argument helpers in the staged std.process facade.

arg_i32_result
arg_i32_or_zero
arg_i64_result
arg_i64_or_zero
arg_f64_result
arg_f64_or_zero
arg_bool_result
arg_bool_or_false

The helpers are ordinary source wrappers over the existing argument lookup and concrete parse result families. Glagol adds no new parser, checker, runtime, or LLVM semantics for this release.

Explicit Deferrals

No automatic standard-library imports, no compiler-loaded std source, no process spawning, no exit/status control, no current-directory APIs, no signal handling, no shell parsing, no subcommands, no richer CLI framework APIs, no rich host errors, no new compiler-known std.* runtime names, no stable ABI/layout guarantees, and no beta maturity are included.

exp-66

Release label: exp-66

Release date: 2026-05-20

Release state: released experimental fs-typed-read stdlib gate

Summary

Glagol exp-66 gates source-authored typed filesystem read helpers in the staged std.fs facade.

read_i32_result
read_i32_or_zero
read_i64_result
read_i64_or_zero
read_f64_result
read_f64_or_zero
read_bool_result
read_bool_or_false

The helpers are ordinary source wrappers over the existing text-read and concrete parse result families. Glagol adds no new parser, checker, runtime, or LLVM semantics for this release.

Explicit Deferrals

exp-65

Release label: exp-65

Release date: 2026-05-20

Release state: released experimental env-typed stdlib gate

Summary

Glagol exp-65 gates source-authored typed environment helpers in the staged std.env facade.

The release expands the local source-authored env fixture at examples/projects/std-layout-local-env/ with a local string.slo parse wrapper module, expands the explicit std-import-env/ project, adds deterministic present/missing/invalid environment setup to focused integration coverage, and extends promotion-gate inventory/alignment checks for these helpers:

get_i32_result
get_i32_or_zero
get_i64_result
get_i64_or_zero
get_f64_result
get_f64_or_zero
get_bool_result
get_bool_or_false

The helpers are ordinary source wrappers over the existing environment lookup and concrete parse result families. Glagol adds no new parser, checker, runtime, or LLVM semantics for this release.

Explicit Deferrals

No automatic standard-library imports, no compiler-loaded std source, no environment mutation, no environment enumeration, no environment writes, no generic configuration helpers, no rich host errors, no new compiler-known std.* runtime names, no stable ABI/layout guarantees, and no beta maturity are included.

exp-64

Release label: exp-64

Release date: 2026-05-20

Release state: released experimental num-fallback stdlib gate

Summary

Glagol exp-64 gates source-authored checked conversion fallback helpers in the staged std.num facade.

The release adds a local source-authored num fixture at examples/projects/std-layout-local-num/, expands the explicit std-import-num/ project, adds focused integration coverage, and extends promotion-gate inventory/alignment checks for these helpers:

i64_to_i32_or
f64_to_i32_or
f64_to_i64_or

The helpers are ordinary source wrappers over the existing checked numeric conversion result families. Glagol adds no new parser, checker, runtime, or LLVM semantics for this release.

Explicit Deferrals

No automatic standard-library imports, no compiler-loaded std source, no unchecked narrowing conversions, no saturating conversions, no generic numeric traits, no new compiler-known std.* runtime names, no stable ABI/layout guarantees, and no beta maturity are included.

exp-63

Release label: exp-63

Release date: 2026-05-20

Release state: released experimental fs-fallback stdlib gate

Summary

Glagol exp-63 gates source-authored fallback/status helpers in the staged std.fs facade.

The release expands the local source-authored fs fixture at examples/projects/std-layout-local-fs/, expands the explicit std-import-fs/ project, adds focused integration coverage, and extends promotion-gate inventory/alignment checks for these helpers:

read_text_or
write_text_ok

The helpers are ordinary source wrappers over the existing text filesystem result families. Glagol adds no new parser, checker, runtime, or LLVM semantics for this release.

Explicit Deferrals

No automatic standard-library imports, no compiler-loaded std source, no binary file APIs, no directory traversal, no streaming file IO, no async file IO, no rich host errors, no new compiler-known std.* runtime names, no stable ABI/layout guarantees, and no beta maturity are included.

exp-62

Release label: exp-62

Release date: 2026-05-20

Release state: released experimental env-fallback stdlib gate

Summary

Glagol exp-62 gates source-authored fallback helpers in the staged std.env facade.

The release expands the local source-authored env fixture at examples/projects/std-layout-local-env/, expands the explicit std-import-env/ project, adds deterministic present/missing environment setup to focused integration coverage, and extends promotion-gate inventory/alignment checks for these helpers:

has
get_or

The helpers are ordinary source wrappers over the existing environment lookup result family. Glagol adds no new parser, checker, runtime, or LLVM semantics for this release.

Explicit Deferrals

No automatic standard-library imports, no compiler-loaded std source, no environment mutation, no environment enumeration, no platform/configuration APIs, no rich host errors, no new compiler-known std.* runtime names, no stable ABI/layout guarantees, and no beta maturity are included.

exp-61

Release label: exp-61

Release date: 2026-05-20

Release state: released experimental process-fallback stdlib gate

Summary

Glagol exp-61 gates source-authored fallback helpers in the staged std.process facade.

The release adds a local source-authored process fixture at examples/projects/std-layout-local-process/, expands the explicit std-import-process/ project, adds focused integration coverage, and extends promotion-gate inventory/alignment checks for these helpers:

arg_or
arg_or_empty

The helpers are ordinary source wrappers over the existing process argument result family. Glagol adds no new parser, checker, runtime, or LLVM semantics for this release.

Explicit Deferrals

No automatic standard-library imports, no compiler-loaded std source, no shell parsing, no option/flag parsing, no subcommands, no spawning, no exit/status control, no rich host errors, no new compiler-known std.* runtime names, no stable ABI/layout guarantees, and no beta maturity are included.

exp-60

Release label: exp-60

Release date: 2026-05-20

Release state: released experimental string-fallback stdlib gate

Summary

Glagol exp-60 gates source-authored string parse fallback helpers in the staged std.string facade.

The release adds a local source-authored string fixture at examples/projects/std-layout-local-string/, expands the explicit std-import-string/ project, adds focused integration coverage, and extends promotion-gate inventory/alignment checks for these helpers:

parse_i32_or_zero
parse_i64_or_zero
parse_f64_or_zero
parse_bool_or_false

The helpers are ordinary source wrappers over the existing concrete parse result families. Glagol adds no new parser, checker, runtime, or LLVM semantics for this release.

No automatic standard-library imports, workspace/package std imports, package registry behavior, std.slo aggregator, glob imports, aliases, qualified member access, compiler-known std.* runtime names, broad stdlib APIs, stable ABI/layout/ownership, optimizer guarantees, benchmark thresholds, or beta maturity are included.

exp-43

Release label: exp-43

Release date: 2026-05-19

Release state: released experimental technical whitepaper and design-skill gates

Glagol exp-40 adds a broader local benchmark suite and project license files. The benchmark suite includes math-loop, branch-loop, and parse-loop scaffolds, each with Slovo, C, Rust, Python, and Clojure source slots where the local toolchain is available.

The shared runner validates deterministic checksums, skips missing toolchains, and reports local-machine timing comparisons only. Clojure is detected through clojure, CLOJURE, or CLOJURE_JAR.

Glagol is documented and licensed as MIT OR Apache-2.0, matching the Cargo package metadata. Alpha/beta release criteria are recorded in .llm/.

Explicit Deferrals

No language semantics, compiler optimizations, stable benchmark thresholds, cross-machine performance claims, stable ABI/layout/ownership, package registry behavior, or beta maturity are included.

exp-39

Release label: exp-39

Release date: 2026-05-19

Release state: released experimental math-helper and benchmark-scaffold gates

The call accepts complete finite ASCII decimal text in the narrow -?digits.digits shape, returns ok value for finite parsed f64 values, and returns err 1 for ordinary parse failure, non-finite text, unsupported leading/trailing characters, or out-of-domain input. The concrete (result f64 i32) family is supported for direct fixture flow and existing result helpers without making result handling generic. Source-authored (ok f64 i32 ...), (err f64 i32 ...), and match over (result f64 i32) remain deferred.

The implementation executes in the deterministic test runner, formats through the existing formatter, preserves surface/checked lowering snapshots, and lowers hosted builds through private runtime helper __glagol_string_parse_f64_result.

The promoted fixture is string-parse-f64-result.slo.

Explicit Deferrals

No generic parse, trap-based std.string.parse_f64, leading +, exponent notation, missing digits around ., locale parsing, Unicode digits, underscores, rich parse errors, stable helper ABI/layout, runtime headers/libraries, generic result support, f64 containers, mixed numeric arithmetic, manifest schema changes, or beta maturity are claimed by this slice.

exp-27

Release label: exp-27

Release date: 2026-05-19

Release state: released experimental compiler support

Summary

Glagol exp-27 implements Checked F64 To I32 Result Alpha. The compiler now promotes exactly std.num.f64_to_i32_result : (f64) -> (result i32 i32).

The call returns ok value only when the input is finite, exactly integral, and inside the signed i32 range. It returns err 1 for non-finite, fractional, or out-of-range input without trapping for ordinary conversion failure. The implementation executes in the deterministic test runner, formats through the existing formatter, preserves surface/checked lowering snapshots, and lowers directly to LLVM with ordered range checks before fptosi.

The promoted fixture is f64-to-i32-result.slo.

Explicit Deferrals

No unchecked f64 to i32, casts or cast syntax, generic cast_checked, f32, unsigned or narrower integer families, additional numeric conversion families, f64 parse, mixed numeric arithmetic, numeric containers, stable ABI/layout, runtime headers/libraries, manifest schema changes, or beta maturity are claimed by this slice.

exp-26

Release label: exp-26

Release date: 2026-05-18

Release state: released experimental compiler support

Summary

Glagol exp-26 implements F64 To String Alpha. The compiler now promotes exactly std.num.f64_to_string : (f64) -> string.

The call returns finite decimal ASCII text for promoted finite f64 inputs. It type checks like other promoted standard-runtime names, executes in the deterministic test runner, formats through the existing formatter, preserves surface/checked lowering snapshots, lowers hosted builds through a private runtime helper, and adds machine diagnostic snapshots for arity, type, context, bool context, standard-name shadowing, and helper-name shadowing. The promoted fixture is f64-to-string.slo.

Explicit Deferrals

No f32, f64 parse, generic format/display/interpolation, locale/base/radix/ grouping/padding/precision controls, stable NaN/infinity text, implicit conversion, stable helper ABI/layout, runtime headers/libraries, manifest schema changes, or beta maturity are claimed by this slice.

exp-25

Release label: exp-25

Release date: 2026-05-18

Release state: released experimental compiler support

Summary

Summary

Glagol exp-17 implements Project/Workspace Enum Imports Alpha. Top-level enum declarations now participate in flat project and local workspace visibility: modules can export enum names and consumers can import those enum types alongside functions and structs.

Imported enums preserve exp-4 payloadless and exp-16 unary i32 payload metadata across module and package boundaries. Imported enum values work in function signatures, immutable locals, calls/returns, qualified constructors, same-enum equality, exhaustive enum matches, main, and tests.

The promoted project fixture is examples/projects/enum-imports/.

Explicit Deferrals

Non-i32 payload types, multiple payloads, record variants, enum containers, enum mutation, enum printing, enum ordering/hash/reflection/discriminants, generics, stable ABI/layout, manifest schema changes, registry/package-manager behavior, and beta maturity remain outside this slice.

exp-16

Release label: exp-16

Release date: 2026-05-18

Release state: released experimental compiler support

Summary

Glagol exp-16 implements Unary I32 Enum Payloads Alpha. User enum declarations may mix payloadless variants with unary i32 payload variants, for example (Value i32). Qualified constructors support (Reading.Missing) and (Reading.Value value), and exhaustive enum matches require no binding for payloadless variants and exactly one immutable arm-local i32 binding for payload variants.

Enum values flow through immutable locals, parameters, returns, calls, tests, main, and same-enum equality. Equality compares tag plus payload for payload enums and tag only for payloadless enums. LLVM and the test runner use a compiler-owned { i32, i32 } tag/payload representation for payload enums; this is not a stable ABI or layout claim.

The promoted fixture is enum-payload-i32.slo, with formatter and lowering snapshots plus focused diagnostics for unsupported payload types, constructor arity/type failures, and match binding requirements.

Explicit Deferrals

Non-i32 payload types, multiple payloads, record variants, generic enums/functions, wildcard/rest/nested enum patterns, pattern guards, enum values in containers, enum mutation, enum printing, enum ordering/hash/ reflection/discriminants, runtime/runtime.c changes, stable ABI/layout, manifest schema changes, and beta maturity remain outside this slice.

exp-15

Release label: exp-15

Release date: 2026-05-18

Release state: released experimental compiler support

Summary

Glagol exp-15 implements Result Helper Standard Names Alpha. It accepts std.result.is_ok, std.result.is_err, std.result.unwrap_ok, and std.result.unwrap_err for exactly (result i32 i32) and (result string i32), mapping them to the existing result observer and unwrap behavior.

Legacy is_ok, is_err, unwrap_ok, and unwrap_err remain supported. No std.result.map, std.result.unwrap_or, std.result.and_then, option standard names, generic results, new result payload families, runtime API, manifest schema change, or beta maturity is claimed.

exp-14

Release label: exp-14

Release date: 2026-05-18

Release state: released experimental conformance alignment

Summary

Glagol exp-14 is the Standard Runtime Conformance Alignment release. It aligns docs, fixtures, formatter/lowering snapshots, promotion inventories, and a focused conformance gate over the already released exp-13 surface plus released exp-8 time/sleep support. It is not beta.

This release adds no source syntax, type forms, standard-library operations, runtime APIs, ABI/layout promises, or manifest schema changes.

Gate

The focused conformance gate, full release gate, and Slovo/Glagol review pass together. The new time/sleep fixture uses only std.time.monotonic_ms and std.time.sleep_ms 0; it does not assert positive-duration timing behavior.

exp-13

Release label: exp-13

Release date: 2026-05-18

Release state: released experimental compiler support

Summary

Glagol exp-13 implements Slovo exp-13 String Parse I32 Result Alpha as released experimental compiler support. It is not beta.

The release promotes exactly one standard-runtime call:

std.string.parse_i32_result : (string) -> (result i32 i32)

The operation parses an entire ASCII decimal signed i32 string and returns ok value on success or ordinary parse failure as err 1.

Release State

The fixture, diagnostics, lowering snapshots, and promotion inventories are released experimental compiler-support state after the implementation, diagnostics, lowering-inspector snapshots, runtime/test-runner behavior, promotion gates, release review, and full release gate passed.

No trap-based std.string.parse_i32, float/bool/string/bytes parsing, whitespace/locale/base-prefix/underscore/plus-sign parsing, generic parse API, rich parse errors, Unicode digit parsing, string indexing/slicing, tokenizer/scanner API, stdin line API, manifest schema changes, stable helper ABI/layout, runtime headers/libraries, or beta maturity is claimed.

exp-12

Release label: exp-12

Release date: 2026-05-18

Summary

Glagol exp-12 implements Slovo exp-12 Standard Input Result Alpha as released experimental compiler support. It is not beta.

The release promotes exactly one standard-runtime call:

std.io.read_stdin_result : () -> (result string i32)

The release returns ok with remaining stdin text, including ordinary EOF as ok ""; ordinary host/input failure returns err 1.

Release State

exp-12 is released experimental compiler support after the implementation, Slovo fixture alignment, formatter, diagnostics, lowering-inspector snapshots, test-runner, LLVM/runtime, promotion gates, release review, and full release gate passed.

No trap-based std.io.read_stdin, line iteration, prompt APIs, terminal mode, binary stdin, streaming, async stdin, encoding/Unicode promise, stable helper ABI/layout, runtime headers/libraries, manifest schema change, or beta maturity is claimed.

exp-11

Release label: exp-11

Release date: 2026-05-18

Summary

Glagol exp-11 implements Slovo exp-11 Basic Randomness Alpha. It is released experimental compiler support, not beta.

The release promotes exactly one standard-runtime call:

std.random.i32 : () -> i32

The call returns a non-negative implementation-owned i32 suitable only for basic command-line programs. If native runtime randomness is unavailable, the runtime trap text must be exactly slovo runtime error: random i32 unavailable.

Release State

exp-11 is released experimental compiler support after Slovo and Glagol fixtures, formatter, diagnostics, lowering-inspector snapshots, test-runner, LLVM/runtime, promotion gates, release review, and release gates passed.

No seed APIs, deterministic public sequences, cryptographic suitability, range/bounds APIs, bytes, strings, UUIDs, artifact-manifest schema changes, stable helper ABI, runtime headers/libraries, or beta maturity are claimed.

exp-10

Release label: exp-10

Release date: 2026-05-18

Summary

Glagol exp-10 implements Slovo exp-10 Result-Based Host Errors Alpha. It is released experimental compiler support, not beta.

The release promotes exactly one new concrete result family, (result string i32), and four additive host calls:

std.process.arg_result : (i32) -> (result string i32)
std.env.get_result : (string) -> (result string i32)
std.fs.read_text_result : (string) -> (result string i32)
std.fs.write_text_result : (string string) -> (result i32 i32)

Ordinary host failure returns err 1. The exp-3 calls remain unchanged: argument/read failures still trap, missing environment variables still return "", and writes still return 0 or 1.

Release State

exp-10 is released experimental compiler support after formatter, checker, lowering, diagnostics, test-runner, LLVM/runtime, fixture-alignment, release review, and release gates passed.

exp-9

Release label: exp-9

Release date: 2026-05-18

Summary

Glagol exp-9 is the released experimental hardening slice over the released exp-8 surface. The exp-9 work includes compatibility inventory, migration guide, source-reachable panic audit, benchmark smoke notes, release gate evidence, and deterministic hardening tests in compiler/tests/reliability_hardening.rs.

Controller verification has passed the focused exp-9 hardening test and the full local release gate. Benchmark smoke records structured ToolchainUnavailable for hosted native-build checks because clang was not on PATH in this environment.

exp-9 is hardening-only. It does not add source syntax, type-system behavior, standard-runtime names, runtime capabilities, package features, manifest schema versions, stable ABI/layout promises, public performance thresholds, or beta maturity.

Release State

exp-9 is released experimental compiler support after matching Slovo and Glagol gates.

exp-8

Release label: exp-8

Release date: 2026-05-18

Summary

Glagol exp-8 implements the conservative host time and sleep alpha. It adds exactly two compiler-known standard-runtime calls:

std.time.monotonic_ms : () -> i32
std.time.sleep_ms : (i32) -> unit

std.time.monotonic_ms returns non-negative process-relative host monotonic elapsed milliseconds, saturating to i32::MAX. std.time.sleep_ms accepts non-negative millisecond durations; 0 is valid and deterministic in the test runner.

Diagnostics And Limits

Negative sleeps trap as slovo runtime error: sleep_ms negative duration. Hosted runtime failure to read monotonic time traps as slovo runtime error: monotonic time unavailable; non-negative sleep failure may trap as slovo runtime error: sleep failed.

exp-8 adds no source syntax, wall-clock/calendar API, time zones, high-resolution clock contract, timers, threads, channels, async behavior, scheduling guarantees, cancellation, or stable helper ABI. The current artifact manifest has no general standard-runtime usage structure, so exp-8 does not add one-off time metadata.

exp-7

Release label: exp-7

Release date: 2026-05-18

Summary

Glagol exp-7 implements the experimental test selection and test-run metadata alpha. glagol test <file.slo|project> --filter <substring> and the legacy single-file glagol --run-tests --filter <substring> <file.slo> route select tests by deterministic, case-sensitive display-name substring matching.

Selected tests execute in existing order. Non-selected discovered tests are skipped before evaluation and counted as skipped. Zero matches is a successful run. Text output and artifact manifests expose total_discovered, selected, passed, failed, skipped, and optional filter metadata.

Diagnostics And Limits

Missing filter values, repeated --filter, and use of --filter outside test mode are command-line diagnostics. The exp-6 C-import test-runner boundary is unchanged: selected tests that reach imported C calls report UnsupportedTestExpression, while non-selected C-import tests are skipped before evaluation.

LSP/editor protocols, debug metadata, source maps, SARIF, watch/daemon behavior, documentation comments, lint categories, benchmark behavior, test tags/groups/retries/parallelism, and new Slovo source syntax are deferred. exp-7 is experimental, not beta.

exp-6

Release label: exp-6

Release date: 2026-05-18

Summary

Glagol exp-6 implements the experimental C FFI scalar imports alpha. It accepts top-level imports such as:

(import_c c_add ((lhs i32) (rhs i32)) -> i32)

Imported C functions use conservative C symbol names, accept only i32 parameters, and return only i32 or builtin unit. Calls to imported C functions are allowed only inside lexical (unsafe ...); calls outside unsafe report UnsafeRequired.

Native builds lower imports to LLVM external declarations and direct calls. glagol build --link-c <path> links explicit local C source inputs, and artifact manifests record foreign_imports plus c_link_inputs.

Diagnostics And Limits

The interpreter-style test runner does not execute imported C calls in exp-6; tests that reach a C import report UnsupportedTestExpression. Raw unsafe heads, including ffi_call, remain unsupported operations.

Pointers, raw allocation/deallocation, raw unsafe head execution, ownership/lifetime rules, C exports, callbacks, headers/libraries, broad linker configuration, and stable ABI/layout are deferred. exp-6 is experimental, not beta.

exp-5

Release label: exp-5

Release date: 2026-05-18

Summary

Glagol exp-5 implements the experimental local packages/workspaces alpha. A workspace slovo.toml can declare [workspace] members, and each member can declare [package] name, version, source_root, entry, plus local [dependencies] entries such as mathlib = { path = "../mathlib" }.

The implemented slice builds a deterministic closed local package graph, accepts package-qualified imports such as (import mathlib.math (add_one)), checks cross-package visibility through existing module export lists, and records the workspace/package graph in artifact manifests.

Diagnostics

The exp-5 diagnostic gate covers missing package manifests or packages, duplicate package names, dependency cycles, workspace/dependency/source-root path escapes, invalid package names, invalid package versions, private cross-package visibility, and dependency key/name mismatches.

Explicit Deferrals

Registries, lockfiles, semver solving, aliases, globs, re-exports, generated code, build scripts, publishing, optional/dev/target dependencies, stable package ABI, and remote dependencies remain outside this experimental slice. exp-5 is not beta and is not package-manager support.

exp-4

Release label: exp-4

Release date: 2026-05-18

Summary

Glagol exp-4 implements experimental payloadless user-defined enum support. Enums can be declared with one or more unique variants, constructed through qualified constructors such as (Signal.Red), compared for equality when both operands have the same enum type, passed through immutable locals, parameters, returns, calls, and top-level tests, and matched exhaustively by variant.

The promoted release fixture is enum-basic.slo, byte-aligned with Slovo's supported fixture. Lowering inspector snapshots cover both surface and checked enum forms, and diagnostics snapshots cover the exp-4 boundary cases.

Explicit Deferrals

Payload variants, generic ADTs, type aliases, traits, methods, unqualified variant constructors, enum mutation, enum printing, enum ordering, enum values inside containers, stable layout, and stable ABI claims remain outside this slice. Unqualified variant constructor calls currently report the generic UnknownFunction diagnostic.

Gates

The exp-4 gate covers Slovo/Glagol fixture equality for enum-basic.slo, formatter and lowering-inspector fixtures, enum LLVM discriminant shape, top-level enum tests, and golden machine diagnostics for supported boundary failures.

exp-3

Release label: exp-3

Release date: 2026-05-17

Summary

Glagol exp-3 implements the conservative standard IO and host-environment slice. It adds compiler-known standard-runtime functions:

std.io.eprint : (string) -> unit
std.process.argc : () -> i32
std.process.arg : (i32) -> string
std.env.get : (string) -> string
std.fs.read_text : (string) -> string
std.fs.write_text : (string string) -> i32

Missing environment variables return an empty string. write_text returns 0 on success and 1 on host failure. eprint writes to stderr without adding a newline. Native programs initialize a private runtime process view from host argc/argv.

Runtime traps are:

slovo runtime error: process argument index out of bounds
slovo runtime error: file read failed

The runtime helper symbols are private implementation details and are reserved from source/project names. exp-3 does not stabilize host error payloads, file ownership/lifetime behavior, process layout, runtime ABI, or C helper symbols.

Explicit Deferrals

Networking, async IO, binary IO, directory traversal, terminal control, stdin full-read/iteration, time, randomness, result-string host errors, and stable ABI/layout claims remain outside this slice.

Gates

The exp-3 gate covers checker diagnostics, lowering-inspector fixtures, LLVM runtime-call shape, interpreted host behavior where practical, hosted runtime smoke tests, and trap behavior for process arguments and file reads.

exp-2

Release label: exp-2

Release date: 2026-05-17

Summary

Glagol exp-2 implements the first collections alpha slice from the Slovo contract. It adds one concrete growable vector type, (vec i32), plus compiler-known standard-runtime functions:

std.vec.i32.empty : () -> (vec i32)
std.vec.i32.append : ((vec i32), i32) -> (vec i32)
std.vec.i32.len : ((vec i32)) -> i32
std.vec.i32.index : ((vec i32), i32) -> i32

append returns a new immutable runtime-owned vector. (vec i32) values can flow through immutable locals, parameters, returns, calls, top-level tests, formatter output, lowering inspection, LLVM, runtime C, and the test runner. Vector equality with = compares (vec i32) values by length and element contents.

Runtime traps are:

slovo runtime error: vector allocation failed
slovo runtime error: vector index out of bounds

The runtime helper symbols are private implementation details and are reserved from source/project names. exp-2 does not stabilize vector layout, C ABI, allocator behavior, lifetime, destruction, FFI, or ownership semantics.

Explicit Deferrals

Generic vectors, non-i32 elements, vector mutation through var or set, push aliases, nested vectors, vectors inside arrays/structs/options/results, slices, maps, sets, user-visible allocation/deallocation, and stable layout or ABI promises remain outside this slice.

Gates

The exp-2 release gate covers checker diagnostics, formatter stability, lowering-inspector fixtures, LLVM runtime-call shape, top-level test-runner evaluation, hosted runtime smoke tests, vector trap behavior, allocation-trap probing, promotion-gate inventory, and Slovo fixture alignment without editing Slovo fixtures.

exp-1

Release label: exp-1

Release date: 2026-05-17

Summary

Glagol exp-1 implements the first owned-runtime-string slice from the Slovo contract. It adds compiler-known std.string.concat with signature (string, string) -> string, returning an immutable runtime-owned string. Existing string equality, std.string.len, std.io.print_string, string locals, parameters, returns, and calls can use the result.

No legacy string_concat alias is accepted. The runtime helper is private implementation detail, not a stable ABI, layout, allocator, lifetime, or FFI promise.

Gates

The exp-1 release gate covered checker diagnostics, formatter stability, lowering-inspector fixtures, LLVM runtime-call shape, top-level test-runner evaluation, hosted runtime smoke tests, and Slovo fixture alignment.

v2.0.0-beta.1

Release tag: v2.0.0-beta.1

Release date: 2026-05-17

Summary

Glagol v2.0.0-beta.1 is an experimental gate/readiness release over the completed v1.7 toolchain. It does not add new Slovo source syntax or semantics. The release documents the current supported surface and proves the integrated experimental workflow through project scaffolding, fmt --check, test, doc, and hosted build when the host toolchain is available.

Experimental-Supported Surface

v1.7 CLI and project tooling, including new, fmt --check, fmt --write, doc, test, and hosted build.
Flat local project mode with explicit imports and exports.
v1.5 standard-runtime alpha as the basic IO/string subset: std.io.print_i32, std.io.print_string, std.io.print_bool, and std.string.len.
Fixed-size immutable i32 arrays as the current collection subset.
Existing v1.7 language behavior for strings, structs, option/result values, exact option/result match, and lexical unsafe diagnostics.

Explicit Deferrals

At tag time, the experimental release deferred vectors and growable collections, packages and registries, stable ABI/layout, FFI, executable raw-memory behavior, LSP/watch mode, stable debug metadata, source-map files, direct machine-code output, and self-hosting until future beta work. The later exp-2 slice now implements only the narrow (vec i32) collections alpha.

Release Gates

The experimental gate runs through scripts/release-gate.sh: whitespace checks, cargo fmt --check, full cargo test, and the ignored promotion, binary, and LLVM smoke gates. Full cargo test includes the v1.7 DX gate and the experimental workflow proof.

v1.7

Release tag: v1.7

Release date: 2026-05-17

Summary

Glagol v1.7 is a Developer Experience Hardening release. It adds conservative tooling around the existing Slovo v1.6 language surface and does not introduce new Slovo syntax or semantics.

Tooling Additions

glagol new <project-dir> [--name <name>] scaffolds a minimal project with slovo.toml and src/main.slo.
glagol fmt --check <file-or-project> verifies canonical formatting without writes and reports FormatCheckFailed when a file would change.
glagol fmt --write <file-or-project> writes canonical formatting in place and emits no stdout on success.
glagol doc <file-or-project> -o <dir> writes deterministic Markdown documentation to index.md.
scripts/release-gate.sh runs the local release gate.

Explicit Deferrals

v1.7 does not add package management, workspaces, nested modules, import aliases, semantic reflection, LSP/watch mode, new formatter semantics beyond existing project syntax, or any new Slovo language behavior.

v1.6

Release tag: v1.6

Release date: 2026-05-17

Summary

Glagol v1.6 is the Memory And Unsafe Design Slice release. It mirrors Slovo's conservative v1.6 contract by hardening the reserved unsafe vocabulary and lexical unsafe diagnostics without promoting executable raw-memory behavior. The v1.1 through v1.5 sections below are historical release records.

The compiler-known unsafe operation heads are:

alloc
dealloc
load
store
ptr_add
unchecked_index
reinterpret
ffi_call

Diagnostics And Reservation

Outside lexical (unsafe ...), each unsafe head reports UnsafeRequired before user-function lookup. Inside lexical (unsafe ...), each head reports UnsupportedUnsafeOperation.

These names are reserved from user functions, project imports and exports, parameters, locals, structs, and match payload bindings where the current reservation architecture applies. This keeps the vocabulary available for a future contract without allowing accidental shadowing today.

Explicit Deferrals

v1.6 does not introduce raw pointers, allocation/deallocation semantics, pointer load/store, pointer arithmetic, unchecked indexing execution, reinterpretation, FFI calls, stable ABI/layout promises, runtime C symbols, or raw-memory LLVM lowering.

Release Gates

v1.6 verification covers unsafe-required and unsupported-inside-unsafe diagnostic snapshots for every unsafe head, focused reservation tests for local source and project visibility paths, existing lexical unsafe formatter and lowering fixtures, and regressions proving no raw unsafe operation reaches LLVM lowering.

v1.5

Release tag: v1.5

Release date: 2026-05-17

Summary

Glagol v1.5 is the Standard Library Alpha release. It mirrors Slovo's conservative v1.5 contract by promoting stable source-level standard-runtime names for existing runtime behavior without adding modules, imports, packages, new IO breadth, allocation, Unicode length semantics, or ABI promises. The v1.1 through v1.4 sections below are historical release records.

v1.5 promotes:

std.io.print_i32
std.io.print_string
std.io.print_bool
std.string.len

These are compiler-known source-level standard-runtime names. They do not require imports, do not name user modules, do not create package dependencies, are not foreign functions, and are not stable C ABI symbols.

Legacy print_i32, print_string, print_bool, and string_len remain compatibility aliases. New examples should prefer the promoted std.* names.

Diagnostics And Deferrals

Unknown or unpromoted std.* calls must produce structured diagnostics, with UnsupportedStandardLibraryCall as the suggested code. Arity and type mismatches use the existing diagnostics where applicable. The exact promoted std.* names are reserved from user function/export shadowing.

v1.5 does not support std.io.print_unit, file IO, environment variables, process arguments, time or clocks, collections, allocation, deallocation, ownership, user-defined standard modules, imports or packages for standard-runtime names, overloading, generic standard-library APIs, Unicode scalar/grapheme/display-width string length, stable C ABI symbols, runtime layout promises, or FFI contracts.

Release Gates

v1.5 verification covers parser/lowerer/checker/formatter support for the promoted std.* calls, aligned examples/standard-runtime.slo and tests/standard-runtime.slo fixtures, lowering-inspector snapshots, runtime smoke tests matching legacy stdout and byte-length behavior, diagnostic snapshots for the v1.5 boundaries, and regressions proving v1.4, v1.3, and v1.2 behavior remains unchanged.

v1.4

Release tag: v1.4

Release date: 2026-05-17

Summary

Glagol v1.4 is the Core Language Expansion release. It mirrors Slovo's conservative source-level match contract for existing option/result values without widening into enums, generics, mutation, vectors, or ABI promises.

Promotes match for exactly (option i32) and (result i32 i32) subjects.
Requires exhaustive two-arm forms: some and none for options, ok and err for results.
Adds immutable i32 payload binding for some, ok, and err; payload bindings are visible only inside the selected arm body.
Treats each arm body as an arm-scoped sequential body with one or more expressions; the final expression is the arm value.
Types the match expression as the common arm result type.
Keeps existing is_some, is_none, is_ok, is_err, unwrap_some, unwrap_ok, and unwrap_err supported, while new examples should prefer match for payload-dependent option/result control flow.

Diagnostics And Formatting

The v1.4 diagnostic boundary requires stable codes for match subject type mismatches, unsupported payload types, non-exhaustive matches, duplicate arms, malformed patterns, arm result type mismatches, binding collisions, unsupported mutation, and unsupported option/result container positions.

The formatter target is a canonical multiline match shape: the head and subject stay on the opening line, each arm starts on its own line, pattern lists stay inline, and body expressions use the normal nested body indentation. The formatter preserves arm order and does not repair malformed arm sets.

Deferred From v1.4

User-defined enums or algebraic data types.
Generic, non-i32, or nested option/result payload matching beyond the current v1 limits.
Options/results inside arrays, structs, or other containers.
Mutation of option/result values, struct fields, arrays, or vectors.
i64 or broader numeric expansion.
General (block ...) expressions outside match arms.
Pattern guards, wildcard/rest/catch-all patterns, and destructuring.
Result-oriented standard-library error conventions.
User-catchable exceptions, ownership, lifetime, layout, or ABI guarantees.

Release Gates

v1.4 verification covers parser/lowerer/checker/formatter support for the promoted match surface, fixture alignment with Slovo examples/supported/option-result-match.slo, formatter idempotence for Slovo examples/formatter/option-result-match.slo, lowering-inspector snapshots, LLVM or runtime smoke tests for arm selection and payload binding, diagnostic snapshots for every required match code, and regressions proving v1.3 project mode and v1.2 runtime values remain unchanged.

v1.3

Release tag: v1.3

Release date: 2026-05-17

Summary

Glagol v1.3 implements Slovo's conservative Project Mode And Modules contract. The release target is local, manifest-based, flat multi-file projects while preserving v1.2 single-file .slo command behavior.

Project manifests are named slovo.toml and contain [project] with required name, optional source_root = "src", and optional entry = "main". name is lowercase package-shaped text, source_root must remain under the project root, entry is a flat module identifier, and unknown sections or keys are diagnostics.
glagol check, glagol test, and glagol build enter project mode only when given a project root or the slovo.toml file itself.
Project source discovery is limited to immediate .slo files under the flat source root.
Modules can declare explicit exports, for example (module math (export add_one Point)).
Modules can import explicit exported names, for example (import math (add_one Point)).
Project diagnostics preserve multi-file source identity and cover manifest failures, missing imports, import cycles, duplicate names, visibility failures, ambiguous imports, and unsupported path/module boundaries.
Project artifact manifests record project roots, manifests, source roots, modules, import edges, diagnostics, tests, and build outputs in deterministic order.

Deferred From v1.3

Packages, package namespaces, dependencies, remote registries, lockfiles, and workspaces.
Import aliases, renames, glob imports, qualified imports, conditional imports, and re-exports.
Nested or hierarchical modules.
Project formatting, write-in-place formatting, and directory formatting.
Path escapes from the project root or source root, generated sources, watch mode, LSP/editor protocols, and incremental builds.
Build profiles, target triples, cross-compilation, object/library/header outputs, package artifacts, public ABI promises, and stable debug metadata.

Release Gates

v1.3 verification covers manifest parsing and diagnostics, project check/test/build command behavior, examples/projects/basic fixture alignment, diagnostic-family checks for import/export failures, deterministic module-order checks, cross-file related-span checks, project artifact-manifest snapshots for success and failure paths, and single-file regressions proving v1.2 mode is unchanged.

v1.2

Release tag: v1.2

Release date: 2026-05-17

Summary

Glagol v1.2 implements the Slovo v1.2 Practical Runtime Values contract while preserving the v1.1 single-file CLI/toolchain surface.

Immutable string value flow through string let locals, parameters, returns, and calls returning strings.
String equality through =.
String byte length through temporary compiler/runtime intrinsic string_len.
Boolean printing through temporary compiler/runtime intrinsic print_bool.
Deterministic runtime trap messages and process exit code 1 for array bounds failures and option/result unwrap failures.

Deferred From v1.2

print_unit.
Mutable strings, string var locals, and set of string locals.
String concatenation, indexing, slicing, ownership, allocation/free, and stable ABI/layout/FFI promises.
Strings inside arrays, structs, options, or results.
Project mode, imports, package management, and multi-file modules.
Any change to the v1.1 CLI/toolchain surface.

Release Gates

Final v1.2 verification includes the existing v1.1 gates plus fixture alignment for string-value-flow.slo and print-bool.slo, formatter idempotence, lowering-inspector snapshots, diagnostic snapshots for deferred forms, runtime smoke tests for strings and traps, and process-exit tests for runtime traps.

v1.1

Release tag: v1.1

Release date: 2026-05-17

Summary

Glagol v1.1 productizes the hosted single-file toolchain without expanding the Slovo v1 language surface.

Canonical Commands

Added glagol check <file.slo> for parse/lower/check/backend-support validation with no primary output.
Added glagol fmt <file.slo> as the canonical formatter command.
Added glagol test <file.slo> as the canonical top-level test runner.
Added glagol build <file.slo> -o <binary> for hosted native builds through emitted LLVM IR, runtime/runtime.c, and Clang.
Preserved v1 compatibility aliases: default LLVM emission, --emit=llvm, --format, --print-tree, --inspect-lowering=surface, --inspect-lowering=checked, --check-tests, and --run-tests.

Diagnostics, Manifests, And Exit Codes

Added --json-diagnostics newline-delimited JSON diagnostics using slovo.diagnostic schema version 1.
Added --no-color across canonical commands and compatibility modes.
Extended artifact manifests with command modes, diagnostics encoding, no-output check manifests, build output artifacts, and failure manifests when --manifest <path> has been parsed.
Implemented the v1.1 exit-code table: 0 success, 1 source/input/test failure, 2 usage error, 3 hosted toolchain failure, 4 internal compiler error, and 5 manifest or output artifact write failure.

Hosted Build

glagol build locates Clang through GLAGOL_CLANG or PATH.
Missing Clang, missing runtime C, and failed Clang execution are reported as toolchain failures with exit code 3.
Native output is staged through a temporary file in the destination directory before replacing the requested -o path on success.
Project mode, profiles, cross targets, object/library outputs, custom linker flags, and stable ABI promises remain deferred.

v1

Release tag: v1

Release date: 2026-05-17

Summary

Glagol v1 is the compiler release for the Slovo v1 contract. It keeps the tree-first compiler pipeline visible, expands value flow beyond v0, and hardens the CLI/tooling surface without claiming direct native executable output.

The default successful primary output remains LLVM IR text. Native execution is the explicit external workflow: emitted LLVM IR plus runtime/runtime.c and Clang.

Promoted v1 Value Flow

Added immutable struct locals, struct parameters, struct returns, calls returning structs, and stored field access for the promoted Slovo v1 struct slice.
Added immutable fixed-size i32 array locals, parameters, returns, calls returning arrays, and runtime-checked dynamic indexing with a runtime trap.
Added option/result value flow for the i32 subset, including immutable option/result locals, parameters, calls returning option/result values, tag observation, and explicit payload extraction with trap-based invalid unwraps.
Added a narrow string runtime slice: direct string literals lower to borrowed immutable NUL-terminated static storage as LLVM ptr, and the temporary print_string intrinsic prints one string plus a newline through the runtime.
Kept full option/result matching, full string value flow, broad runtime printing, raw unsafe memory/FFI operations, stable ABI/layout promises, and stable debug metadata deferred for the v1 scope freeze.

CLI Polish

Added --emit=llvm as the explicit spelling for the default LLVM IR emission mode.
Added -o <path> to route successful primary output to a file instead of stdout.
Added --version, reported from Cargo package metadata.
Kept stdin source input deferred until source naming and span behavior are specified.
Kept JSON diagnostics and lowering-inspection output deferred until the text contract needs a versioned machine-readable companion.

Slovo v1 Tooling Contract

Updated machine diagnostics to the Slovo v1 textual schema with root (diagnostic ...), (schema slovo.diagnostic), and (version 1).
Added --manifest <path> to write slovo.artifact-manifest version 1 manifests for successful primary modes and source-diagnostic failures.
Added UnsupportedUnitSignatureType diagnostics for user-written unit parameter and return signatures while keeping unit internal to compiler/runtime unit-producing forms.
Added golden lowering-inspector snapshots for every promoted v1 fixture in both surface and checked modes.
Audited the golden diagnostic matrix and added snapshots for the current unsupported string escape, string literal, and bare string expression boundaries.
Kept primary output on stdout or -o and diagnostics on stderr; direct native executable output remains deferred behind the LLVM-plus-Clang workflow.
Clarified that artifact manifests are invocation records for textual artifacts, not native executable output.

Formatter And Inspection Stability

Added the v1 formatter stability contract for supported comments, nested promoted forms, and long inline forms.
Added full-line comment preservation fixtures and structured UnsupportedFormatterComment rejection for unsupported comment positions, including same-line/trailing comments.
Added golden --inspect-lowering=surface and --inspect-lowering=checked snapshots for every promoted v1 fixture family, including formatter comments/stability fixtures accepted by inspector mode.
Expanded the golden diagnostic matrix for Slovo's required rejected v1 boundaries: struct duplicate/unknown/mutation shapes, non-i32 option/result signature payloads, and array promoted-flow type mismatches.

Release Gates

Final v1 verification covers:

cargo test
cargo fmt --check
cargo test --test promotion_gate -- --ignored
cargo test --test binary_smoke -- --ignored
cargo test --test llvm_smoke -- --ignored
git diff --check

v0

Release tag: v0

Release date: 2026-05-16

Release commit: 4ccd201

Summary

Glagol v0 is the first released compiler for Slovo. It implements the Slovo v0 language contract as a Rust binary CLI that parses, formats, checks, tests, inspects, lowers, and emits LLVM IR for the supported fixture set.

v0 intentionally keeps the compiler surface small and explicit. The default output is LLVM IR text; direct executable output remains deferred.

CLI Surface

Supported v0 commands:

glagol <file.slo>
glagol --format <file.slo>
glagol --print-tree <file.slo>
glagol --inspect-lowering=surface <file.slo>
glagol --inspect-lowering=checked <file.slo>
glagol --check-tests <file.slo>
glagol --run-tests <file.slo>
glagol test <file.slo|project> --filter <substring>
glagol --run-tests --filter <substring> <file.slo>

CLI behavior:

success writes primary output to stdout and exits 0
source diagnostics write human and machine diagnostics to stderr and exit 1
input/read failures exit 1
usage errors exit 2
--help writes usage information to stderr and exits 0
experimental exp-7 test filtering selects by case-sensitive test display-name substring, skips non-selected tests before evaluation, and records total_discovered, selected, passed, failed, skipped, and optional filter metadata in test reports/manifests

Supported Fixture Set

Glagol v0 supports these compiler fixtures:

examples/add.slo
examples/array.slo
examples/if.slo
examples/local-variables.slo
examples/option-result.slo
examples/struct.slo
examples/unsafe.slo
examples/while.slo
tests/top-level-test.slo

These are aligned with Slovo's examples/supported/ and examples/formatter/ fixtures by the ignored monorepo alignment gate.

Compiler Pipeline

The v0 pipeline is:

.slo source
-> tokens
-> S-expression tree
-> AST
-> typed AST
-> LLVM IR text

The compiler keeps source-reachable failures diagnostic-first. Checked source forms should not reach backend panics.

Test Coverage

The v0 suite covers:

supported fixture LLVM shape
canonical formatter behavior
parse-tree printing
surface and checked lowering inspection
top-level test checking and running
structured machine diagnostics
source spans and line/column ranges
value-producing if
locals and assignment
while
structs
arrays and literal indexing
option/result constructors
lexical unsafe
CLI usage and exit codes

Explicit Deferrals

Glagol v0 does not implement:

direct executable output
-o <path>
explicit --emit=llvm
stdin source input
--version
runtime strings
dynamic array indexing and runtime bounds traps
complete struct, array, and option/result value flow
raw memory operations
FFI
stable ABI/layout promises
package management
direct machine-code backend

Post-v0 Direction

Post-v0 work starts in .llm/V1_ROADMAP.md and should remain locked to Slovo's SPEC-v1.md.

The recommended first compiler slice is struct value flow after Slovo specifies the v1 contract for struct locals, parameters, returns, and stored field access.

195 KiB Raw Permalink Blame History

Glagol Release Notes

Release Maturity Policy

Unreleased

1.0.0-beta.19

Summary

Explicit Deferrals

1.0.0-beta.18

Summary

Explicit Deferrals

1.0.0-beta.17

Summary

Explicit Deferrals

1.0.0-beta.16

Summary

Explicit Deferrals

1.0.0-beta.15

Summary

Explicit Deferrals

1.0.0-beta.14

Summary

Explicit Deferrals

1.0.0-beta.13

Summary

Explicit Deferrals

1.0.0-beta.12

Summary

Explicit Deferrals

1.0.0-beta.11

Summary

Explicit Deferrals

1.0.0-beta.10

Summary

Explicit Deferrals

1.0.0-beta.9

Summary

Explicit Deferrals

1.0.0-beta.8

Summary

Explicit Deferrals

1.0.0-beta.7

Summary

Explicit Deferrals

1.0.0-beta.6

Summary

Explicit Deferrals

1.0.0-beta.5

Summary

Explicit Deferrals

1.0.0-beta.4

Summary

Explicit Deferrals

1.0.0-beta.3

Summary

Explicit Deferrals

1.0.0-beta.2

Summary

1.0.0-beta.1

Summary

Explicit Deferrals

1.0.0-beta

Summary

Explicit Deferrals

exp-125

Summary

exp-123

exp-124

Summary

Explicit Deferrals

exp-123

Summary

Explicit Deferrals

exp-122

Summary

Explicit Deferrals

exp-121

Summary

Explicit Deferrals

exp-120

Summary

195 KiB

Raw Permalink Blame History