Current Status

This is the canonical public implementation-status page for seed. The current language specification is seed/docs/lang-spec.md; its grammar and semantic chapters live under seed/compiler/llvm. A roadmap item is not implemented merely because it is proposed; completed gates require their named closure evidence.

Compiler

seed/compiler/llvm is the operational repository compiler and launcher. Gates 0-24 are complete for their recorded scopes. The verified pipeline is:

source → lexer/parser → semantic graph → typed HIR/CFG
       → ownership/provenance/effects/loans → cleanup planning/verification
       → MIR → target layout/ABI → verified low MIR → LLVM

Source imports and .sdi emission execute the same mandatory safety chain. The normal and ASan/UBSan suites pass 1,496 compiler checks plus seven unit binaries at the current baseline. Gate-specific evidence is under seed/compiler/llvm/tests/GATE*_BASELINE.md.

Self-hosted compiler

Complete self-hosting is an active Linux x86-64 track governed by roadmap-self-hosted.md. The operational LLVM compiler remains the semantic and ABI oracle until the SH20 cutover.

SH0 has frozen the Linux x86-64 bootstrap contract, dependency boundary, and traceability. SH1 has closed the compiler-grade libraries and host substrate. SH2 is in progress with token, lexer, AST, parser, formatter, and minimal frontend-command slices implemented. Semantic analysis, compiler IRs, the LLVM bridge, native x86-64/ELF emission, native fixed-point bootstrap, runtime, linker, release provenance, and operational cutover remain later gates. Non-Linux ports are explicitly deferred until after the first cutover.

The Linux-native allocator uses precise 16-byte through 8-KiB slab classes, a bounded process-wide empty-slab cache, and unmaps excess empty slabs. box<t> is a single-pointer owner, while ?box<t> uses its audited null niche and therefore also occupies one pointer. Schema-11 .sdi preserves null-niche nominal representation across separate compilation. Gate 18 schema-12 interfaces add exclusive mutable receivers, generic templates, borrowed-return provenance, and fallible application-boundary contracts. Gate 19 schema-13 interfaces add exact target/profile/runtime identity and verified public inline bodies. Gate 20 schema-14 interfaces additionally preserve public immutable scalar, text, tuple, struct, and nested-array constants for source-elided consumers; the compiler emits typed read-only globals and checked projections. Gate 21 has an audited uninitialized-capacity primitive used internally by byte buffers and I/O; io.input_stream provides bounded incremental reads, geometric growth copies only initialized prefixes, and direct spare-capacity I/O is covered by its baseline.

Superseded compiler trees were removed after cutover. Their relevant behavior classifications survive in compiler/llvm/COMPATIBILITY.md and migrated regressions; they do not define current compiler semantics.

Gate status

Source encoding and text

• .sd source files are UTF-8 by contract.
• string is owned valid UTF-8.
• str is a borrowed read-only UTF-8 pointer-plus-byte-length view.
• String literals have static storage and type str.
• Comments and string contents may contain Unicode.
• len reports byte length. The ordinary text package validates and iterates Unicode scalars allocation-free; grapheme segmentation, normalization, and locale behavior remain library work.
• Source identifiers intentionally remain ASCII lower snake case; constants are ASCII upper snake case.

The loader validates every source as canonical UTF-8 before lexing and rejects embedded NUL, overlong encodings, surrogates, truncation, and values beyond Unicode's maximum scalar. Decoded string literals are validated as well.

Phase-1 f-string interpolation is implemented for str, borrowed string, bool, and builtin integers. Construction produces ephemeral format_args without heap allocation; direct output uses file.write_*_format, while .to_string()? explicitly materializes an owned string. Phase 2 implements integer base conversion; bounded width/fill/alignment; exact fixed and deterministic scientific/general f32/f64 conversion without libc; and direct static custom formatting through allocation-free borrowed display.display() -> str and debug.debug() -> str implementations.

Implemented language surface

• immutable/mutable/linear bindings and upper-snake constants;
• functions, implicit-receiver methods, destructors, generics, traits, impls;
• lower-snake structs, ADTs, raw unions, arrays, slices, tuples, option/result;
• expression-oriented blocks and if, plus while, allocation-free for, exhaustive match, break, continue, and early ret;
• checked indexing for all builtin integer widths; variable-index reads are supported on []u8 function parameters and the original slice from bytes.view(). Scope mutable views within a block and use read-only []u8 function parameters or the original slice for variable-index access;
• explicit unsafe raw memory, atomics, volatile access, address spaces, FFI, syscalls, raw union access, and architecture intrinsics;
• structured spawn, regions, runtime profiles, and separate compilation.
• allocation-free non-escaping closures, explicit fallible boxed closures, inferred callback effects, and schema-16 source-elided callable contracts;
• typed phase-1/2 f-strings with single evaluation, literal-brace escaping, format specifications, static display/debug traits, allocation-free segmented output, and fallible owned materialization.

The clean grammar does not currently implement legacy enum, capitalized nominal names, return, # comments, built-in chan<t>/send/recv, detached spawn, recursive closures, generators, macros, exceptions, async/await, or lifetime syntax.

Ownership and safety

The common model is: copy scalars, move resources, borrow zero-copy views, and clone explicitly. Cleanup runs exactly once on structured exits. Panic, trap, and abort do not unwind or run lexical cleanup/destructors.

Ownership/place/provenance facts propagate through aliases, blocks, branches, loop fixed points, fields/nested fields, known array indexes, tuples, ADTs, option/result, generic aggregates, channels/tasks, function values/indirect calls, parameters/returns, and source-elided .sdi. Dynamic-index moves of resource elements remain rejected.

linear t has exactly-once semantics across those same implemented shapes. @borrow receiver/input-derived views retain provenance without lifetime syntax. Unsafe code assumes explicit raw obligations but does not disable safe ownership of surrounding values.

Plain closures are stack-backed and non-escaping. Captures copy or move in first lexical-use order, remain immutable, and clean exactly once. box |...| explicitly allocates an escaping callable and returns result<box fn(...) -> t, alloc_error>; boxed callables are move-only, non-cloneable, non-sendable, and region-confined when region allocated. Seed callbacks use one-pointer code/environment descriptors, while platform function pointers remain thin and accept named functions only.

Text, bytes, and regions

• owned string moves; .clone() creates an explicit independent owner;
• bytes is unique mutable binary ownership;
• shared_bytes is a shared read-only handle with explicit retain/clone;
• compatible owner/array views are allocation-free and provenance checked;
• owned conversions return result<..., alloc_error>;
• region(capacity) { body } provides nested aligned checked bump allocation;
• safe values/views/pointers tied to a region cannot escape it;
• region-bound tasks join before region cleanup.
• str.slice enforces UTF-8 boundaries, while str.equal and ASCII delimiter search remain allocation-free;
• the ordinary text, box, vec, and sort packages provide safe token ranges, recursive ownership, checked mutation, and static ordering.

Concurrency

spawn is structured: task groups drain on every edge leaving their lexical owner before cleanup. Captures copy or move according to capability; sharing is explicit, and cross-task values require send/sync as appropriate.

compiler/llvm/libs/task is an ordinary generic library providing ownership- split channels, typed one-shot task joins, events, cancellation, waitgroups, semaphores, barriers, and locks. The direct spawned-body ABI still returns void, so postfix ? cannot cross the task boundary directly. Gate 15 adds the typed library surface task_result_new, task_result_complete_ok/error, and task_result_wait over the same linear, lexically joined endpoints. Function values and inferred closures may use @no_runtime_effects fn(...) to require a complete empty runtime-effect summary; unknown unqualified indirect calls remain rejected in restricted profiles. Boxed callbacks cannot cross spawn because they do not provide send.

Libraries and linkage

.sdi interfaces preserve public types, generic templates/common instances, effects, ownership, provenance, destructor, clone, target, build/runtime profile, dependency, and ABI identity. Schema 13 preserves verified inline bodies and body hashes; schema 14 adds verified public recursive immutable constant payloads; schema 15 adds callable effect contracts; schema 16 adds boxed callable signatures, inline closure bodies, and callable representation identity. A library wrapper does not publish an orphan method specialization whose generic method owner comes from an imported package; source-elided consumers rematerialize that instance from the dependency's template. Hosted seed libraries link dynamically by default; --static selects static seed dependencies. Artifact publication is atomic and corrupt, stale-schema, profile-, target-, or ABI-mismatched interfaces fail closed.

The launcher incremental build/run path stages safe packages for typed I/O, process views, integer parsing, portable math, byte buffers, slices, boxes, networking, serialization, tasks, generic collections, and systems wrappers. Gate 18 adds schema-12 @mut vectors and safe benchmark/application consumers; Gate 19 adds schema-13 inline math/system leaves and disjoint slice partitions. These remain ordinary imported packages, not hidden language built-ins.

Registry resolution, lockfiles/download cache, package add/update, cache pruning, documentation generation, LSP, and incremental object/interface cache are implemented by the Gate 15 tooling. Gate 17 stages bare core and ordinary manifest dependencies into profile/target-qualified dynamic stores by default, reuses installed generations without recompilation, and implements transactional user/system seed install plus reference-aware seed uninstall. Explicit --static and --static=all remain independent linkage choices.

Build profiles and performance

--release uses seed-safe-o2-v1; --release-small uses seed-safe-oz-v1. Bounds, discriminant, provenance, ownership, and cleanup guards remain unless LLVM proves them redundant. ThinLTO, PGO, and static linkage are explicit independent options. No operational unchecked profile exists.

Gate 13 compares equivalent numeric, parsing, collection, allocation/string, structured-task, networking, dynamic-call, startup, RSS, and artifact-size workloads against Clang C and Rust. On the closure host, seed remains within the 0-10% ordinary-runtime target for the enforced corpus. This is controlled workload evidence, not a universal claim that every seed program beats C/Rust.

Gate 12's closure-host 100k full-check median is 0.41 s at 177,504 KiB against budgets of 3.00 s and 196,608 KiB. See GATE12_BASELINE.md and GATE13_BASELINE.md for hardware/toolchain metadata and interpretation.

Target status

Object support is not the same as executable hosted support. The canonical matrix is compiler/llvm/tests/GATE14_TARGET_MATRIX.tsv.

Gate 14's required Intel runner, SDK, ABI, FFI, dynamic-library, separate-compilation, corruption, loader, and regression requirements pass. macOS arm64 remains an independently labeled native host rather than a substitute for the Intel closure row.

CLI and tooling

The repository launcher provides new, check, format, incremental build, run, test, package resolution, install/uninstall, doc, lint, LSP, and publish --check, plus direct compiler flag forwarding and file.sd -o output. Remote registry publication/signing is not implemented; the existing publish command performs local validation only.

The direct compiler formats source, prints semantic/IR forms, emits/reads/hashes .sdi, emits LLVM/object/shared/static/binary artifacts, installs target/ABI- qualified libraries, and executes supported targets. Its executable help is the authoritative flag list:

seed/compiler/llvm/build/seed --help

Documentation source of truth

Historical documents may describe llvm-v1, the v2 prototype, or assembly stub directories that no longer exist. They must be explicitly labeled and must not be used as current clean-language guidance.