Current Status — 0.10.0 pre-launch (product as service)

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.

Product 0.10.0 is pre-launch with waitlist 100, playground WASM, and support chatbot on seed-lang.com. grove → catalog, pod → crate-like src|bin with central ~/.seed versioned cache. 1.0 stable has no horizon and no real users yet; service, libs, publish (private), code/binary repo, and per-pod docs are the launch focus.

Compiler — 0.10.0

seed/compiler/llvm is the operational repository compiler and launcher. Gates 0-24 are complete for their recorded scopes, as are Gates 26, 29, and 30. Gate 25 (match ergonomics: _ wildcard discard, temporary materialization, ref borrow patterns), Gate 27 (module-qualified module.symbol access), and Gate 31 (floating-point determinism contract) are complete, closed 2026-08-13. Gates 25 and 27 had been recorded complete on 2026-07-29 by a documentation- only commit; verification on 2026-08-13 showed the compiler did not implement their features, they were reopened, and the implementations landed the same day. Gate 28 (structured build output) is complete. Gate 29, ownership analysis scalability for large functions, is complete — ownership on a 4,068-block function dropped from 264s to 1.2s. Gate 30, parallel backend codegen, is complete. Gates 32 (actionable diagnostics), 33 (safe byte write-target), and 34 (fallible spawn) are complete, closed 2026-08-13. Gate 35 (specification critical-path surface: full let type annotations, size_of/align_of compile-time queries, and real link_name with schema-17 interfaces) is complete, closed 2026-08-20. Gate 36 (multiple trait bounds on generic parameters) and Gate 37 (generic impl blocks, impl<t> trait for name<t> with recursive bound satisfaction) are complete, closed 2026-08-20. Gate 38 (residual review findings: irrefutable let patterns, fence-mode overflow hardening, and the backend trust-invariant and grammar alignment documentation) is complete, closed 2026-08-20. Gate 39 (compiler ergonomics and facilitation: shape-aware M007 deduplication of transitively re-exported imports, W900 checked-index unary and C023 double-index desugaring, omitted-bool-field default, array-literal element coercion, and check=build verifier parity) is complete, closed 2026-08-23. The reboot roadmap (Gates 0-39) is fully closed for its recorded scopes; future hardware-enablement work is planned as Gates 40-46. 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,571 compiler checks (3 skipped: runner-dependent) plus eight 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 has closed the self-hosted source loader, lexer, parser, AST, diagnostics, and formatter. SH3 has closed modules, canonical types, capabilities, signatures, traits/impls, parsed generic typed-HIR materialization, and schema-16 interfaces. SH4 (ownership, provenance, effects, loans, exhaustiveness, and cleanup parity) is in progress. 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: value names use lower snake case, nominal types and variants use UpperCamelCase, and 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;
• UpperCamelCase structs, enum ADTs, raw unions, arrays, slices, tuples, Option/Result;
• expression-oriented blocks and if/else if/else, plus while, allocation-free for, exhaustive match, break, continue, and early return;
• 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 type-based ADT spellings, lower snake case nominal identifiers, ret/elif and # 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. Borrowed-endpoint in-place channel operations keep one-shot wrappers whole, so source-elided generic task consumers can carry move-only payloads with user destructors without bypassing exact cleanup. 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.

The Grove network-client foundation now includes owned OpenSSL 3 TLS client/server contexts, bounded streaming HTTP/1.1 GET, and HTTPS with mandatory certificate and hostname/IP verification. Content-length, chunked, and close-delimited bodies share one exact-cleanup incremental owner and can transfer into codec callbacks without buffering the complete payload. macOS ARM64 executes the hermetic TLS/HTTP rows, and their package graphs cross-build for Linux AArch64. The URL parser now exposes bounded borrowed absolute components; fetch composes them through the system IPv4 resolver and follows bounded absolute or relative redirects with dot-segment removal and HTTPS downgrade rejection. One bounded application-supplied Authorization value is accepted only over HTTPS and retained only across same-origin redirects; socket/TLS deadlines remain typed through handshake and body I/O. IPv6/dual-stack selection, bounded resolver cancellation, cookies, decompression, cache policy, authentication-scheme negotiation and credential lifecycle, pooling, public-WAN execution, and physical mobile evidence remain separate.

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.

The Adaptive UI UI9 native-service bridge contract is version 2. It retains bounded 4096-byte UTF-8 clipboard snapshots and adds blocking typed information/warning/error dialogs with 256-byte titles, 2048-byte messages, and platform-neutral acknowledged/cancelled/yes/no results. Headless, native macOS ARM64 AppKit, Linux x86-64 X11, and Windows x86-64/Wine debug/release gates pass. Independent processes prove clipboard exchange; native NSAlert, an owned X11 modal window, and MessageBoxW execute all four response classes with exact close. Rich clipboard formats, file dialogs, Wayland/mobile adapters, and physical Windows remain separate evidence.

The Adaptive UI UI9 plugin host contract is version 4 while the plugin ABI remains version 1. Native macOS ARM64, Linux x86-64, and Windows x86-64/Wine debug/release gates retain up to sixteen distinct generation-checked owners, accept up to eight semantic-versioned capabilities with legacy fallback, classify them as numeric or bounded 4096-byte UTF-8 transforms through one complete optional signature group, reject partial catalog/signature groups, duplicate identifiers, capacity overflow, and stale handles, and prove independent exact unload/reopen. Schema-2/3/4/5/6/7 dependency plans additionally retain four Seed-authored plugins simultaneously in dependency-first order, enforce strict exact/caret/tilde semantic-version and capability requirements, skip and count absent optional packages while failing closed on present invalid or incompatible ones, invoke a negotiated numeric capability and a negotiated UTF-8 capability, expose bounded indexed transforms, expose the unique permission union, deny permissioned plans by default, preflight explicit grants before opening any owner, and close in reverse. Schema 6 freezes the declared signature and checks it against the loaded binary before publication; schema 7 freezes bounded permission declarations and grant-aware package policy. These grants do not sandbox native code. Package host contract 3 additionally streams a domain-separated SHA-256 digest over the exact bounded manifest and binary, retains a private read-only POSIX snapshot or a replacement-denying Windows handle, and loads that exact resource. Seed exposes opt-in Ed25519 verification and verified-open operations; independent debug/release fixtures agree on the digest, reject manifest or binary tampering, and prove stable execution after an adversarial source-replacement attempt on macOS, Linux, and Windows/Wine. grove-ui-plugin-trust adds a bounded application-owned publisher/key policy with one active and one overlap key, explicit rotation/revocation, package and repository trusted-open APIs, and whole-dependency-plan preflight. The same three desktop debug/release rows reject missing records, mismatching signatures, and revoked current/rotated keys before activation. Physical Windows, pinned authority-root provisioning/rotation, transparency/timestamp policy, sandboxing, and platform-view composition remain separate evidence.

grove-ui-plugin-trust-store host contract 1 persists the complete bounded application trust policy plus up to eight minimum accepted catalog sequences in one canonical 64-KiB document. It publishes through a private synchronized part file, OS lock, and atomic replacement inside one explicit existing root. Native macOS ARM64, Linux x86-64, and Windows x86-64/Wine debug/release gates cover active/overlap/revoked key round-trips, monotonic sequence advancement, rollback and corruption rejection, stale-part recovery, and exact cleanup. grove-ui-plugin-trust-bundle verifies one canonical root-pinned Ed25519 schema-1 policy envelope with bounded authority metadata, freshness, validity, and sequence anti-rollback. grove-ui-plugin-trust-distribution retrieves the envelope only over verified HTTPS. The composed contract loads the durable minimum sequence, replaces the complete policy, advances that sequence, and atomically saves only after successful verification. The same three desktop debug/release rows reject invalid signatures, wrong authority, expiry, replay, HTTP, non-200 responses, and oversized bodies without mutating sequence 8. Authenticated delivery uses the shared HTTPS-only, same-origin credential policy. Envelope GETs use three total attempts with capped 100/200 ms exponential backoff for transport failures and the shared transient HTTP status set. The exact-URL raw-envelope cache fallback is used only for transient fetch failures; every hit repeats root-pinned signature, freshness, validity, and retained-sequence verification, and only an application-verified envelope is stored. Pinned authority-root provisioning/rotation, secure-clock and transparency/timestamp policy, conditional HTTP revalidation, cache expiry/eviction/quota/encryption, Retry-After/jitter policy, authentication-scheme negotiation and credential acquisition/refresh, encryption, sandboxing, and physical Windows remain separate.

The Adaptive UI UI9 plugin generations host contract is version 3. It retains a caller-selected one to eight validated local generations behind the unchanged public active path, reports the contiguous history count, and returns owned semantic-version metadata by tentative inspection. It swaps any selected index through Seed validation. Upgrade commit durably records its retention bound, rotates or prunes fixed slots, and finishes after an interruption only because the exact staged package already passed validation. Tentative rollback recovery restores the prior active bundle. Native macOS ARM64, Linux x86-64, and Windows x86-64/Wine debug/release gates cover the full eight-entry bound, selected rollback, pruning, interrupted rotation/publication/rollback, invalid candidates, and normal/interrupted removal of the active bundle plus all history. Remote update discovery and live forced-process/power-loss evidence remain separate.

The initial grove-ui-plugin-update slice now closes bounded, artifact-authenticated explicit-URL updates for permission-free and explicitly granted packages. It composes standard HTTP/HTTPS fetching, canonical archive extraction, caller-selected Ed25519 credentials, trust and permission preflight before native loading, and retained generation publication behind a per-package OS file lock and one synced private part file. Native macOS ARM64, Linux x86-64, and Windows x86-64/Wine debug/release gates reject invalid signatures, missing grants, and caller-bound overflows without changing the installed package or history, then publish a valid permissioned update and prove permission-aware rollback. grove-ui-plugin-catalog adds a 64-KiB schema-1/2 catalog with up to 32 bounded releases, order-independent highest-compatible strict-semver selection, a strictly-newer policy, and exact catalog-to-signed-package version binding. Schema 2 authenticates the exact document with a domain-separated detached Ed25519 signature and applies application-selected publisher/key, issue/expiry, clock-tolerance, maximum-validity, and monotonic-sequence anti-rollback policy. The same macOS/Linux/Windows gates cover already-current/no-match behavior plus duplicate, publisher, version-mismatch, invalid-signature, premature, expired, and rollback rejection. Authenticated variants carry one bounded application-selected Authorization value to both catalog and archive requests under the shared HTTPS-only, same-origin redirect policy. Both GETs use three total attempts with capped 100/200 ms exponential backoff for transport failures and the shared transient status set. grove-ui-plugin-remote-cache retains bounded exact-URL raw catalog and archive entries in one explicit root. Only transient fetch failures fall back, and every hit repeats catalog signature/freshness/sequence plus archive, package, version, trust, and permission checks before native loading or publication. Conditional HTTP revalidation, cache expiry/eviction/quota/encryption, Retry-After/jitter policy, authentication-scheme negotiation and credential acquisition/refresh, pinned authority-root provisioning/rotation, transparency/timestamp policy, and physical Windows remain separate.

The shared bounded URL fetcher now passes native macOS/Linux OpenSSL and Windows/Wine WinSock plus WinHTTP/Crypt32 debug/release gates. All three rows preserve the same incremental HTTP body, deadlines, custom-root certificate/hostname verification, bounded relative redirects, and HTTPS downgrade rejection. The authenticated corpus verifies bounded header validation, HTTPS-only use, same-origin forwarding, and cross-origin rejection before credential disclosure. Caller-selected limits provide one to eight total attempts and capped exponential retry/backoff for transport failures and status 408, 425, 429, 500, 502, 503, or 504; the default remains one attempt. IPv6/dual-stack, resolver cancellation, conditional caching, Retry-After/jitter policy, authentication-scheme negotiation and credential lifecycle, pooling, and physical Windows remain separate.

The Adaptive UI UI9 plugin archive host contract is version 3. It retains the strict two-entry schema-1 stored ZIP and schema-2 raw DEFLATE forms and adds a canonical schema-3 raw-LZ4 envelope without a system compression dependency. Native macOS ARM64, Linux x86-64, and Windows x86-64/Wine debug/release gates decode stored, fixed-Huffman, and dynamic-Huffman blocks plus overlapping LZ4 matches; enforce exact compressed input and declared output, CRC, zero padding, a 65,536-block ceiling, manifest/binary/archive bounds, and fixed path-free layout; reject invalid or trailing streams and unsupported or mixed methods; and pass exact package validation, transactional installation/upgrade, schema-1 compatibility, rollback, and cleanup. Remote fetching is provided by the higher-level update and trust-distribution compositions; transparency/timestamp policy remains separate evidence.

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.