Skip to content

Eshkol v1.3.6-evolve

Latest

Choose a tag to compare

@github-actions github-actions released this 19 Oct 11:53
· 7 commits to master since this release
341ac81

Eshkol v1.3.6-evolve — Release Notes

Status: PREPARED FOR PUBLICATION.
Intended release date: Thursday, October 15, 2026.

Final publication requires CTest 823/823 and VM parity 411/411, with no
failed, skipped or infrastructure-only checks. Full source-bound preparation
passed all 823 configured CTest cases and all 411 serialized VM parity cases.
The verified preparation run
binds both measurements to one source commit and build cohort. The release
workflow independently qualifies the final commit and requires ICC ready/100
before publication.

Changes

  • Sparse tensor deltas connect signed DBSP rows to native matrix products.
    The opt-in core.dbsp.tensor module validates fixed shapes, consolidates
    edits, and retains the simultaneous-update cross term. Applying a delta
    copies the dense baseline; native cells retain floating-point semantics.
    (#782)

  • Exact cyclotomic arithmetic is shared by the mathematics examples.
    The opt-in core.cyclotomic module provides exact rational field
    arithmetic, inversion, Galois conjugation, and norms, with refusal when
    arithmetic loses exactness. (#783)

  • Qualification isolates harness controls and pins dependency bytes.
    Windows fetches the same Eigen commit through a checksum-verified archive;
    durable smoke controls use separate roots and preserve failure diagnostics.
    (#781, #784)

  • Windows REPL target initialization shares the static JIT registry. Native
    SDK builds use static LLVM components and matching header declarations.
    Windows CI and staged Windows packages execute an arithmetic evaluation and
    require its result and machine-protocol frames. (#771)

  • Calls and continuations enforce their runtime boundaries. Computed
    operators are evaluated and applied; nonprocedures raise a catchable condition.
    List operations reject invalid operands. Native REPL continuations support
    re-entry within their capturing evaluation and reject use from an earlier
    top-level form. (#763)

  • Language semantics agree across engines. equal? distinguishes exact
    from inexact numbers, native match pair patterns require pairs, and
    raise-continuable returns the handler's value with outer handlers installed.
    type-name uses a shared vocabulary; REPL :type reports the inferred type
    with session definitions in scope. (#768)

  • Tensor differentiation preserves derivative values and shapes. Forward
    tensor arithmetic and matrix multiplication carry derivative components.
    Gradients retain their evaluation point's dimensions. Supported nested vector
    gradients preserve reverse dependencies; unsupported nested tensor and
    perturbed-operand forms report a diagnostic. (#766, #769)

  • CUDA bfloat16 products preserve their declared format. Single and
    batched matrix multiplication distinguish f16 from bf16 and accumulate in
    f32; unsupported formats use the existing f64 fallback. (#762)

  • Deep macro expansion and test timeouts are bounded explicitly. Macro
    traversal uses a work stack, harness deadlines cover complete process groups,
    and stress measurements account for platform time utilities and units. (#765)

  • Construction examples enforce their verdicts. Four witness programs
    fail on a failed check and have native JIT and AOT CTest entries. Example,
    quantum, paper, licensing and editor tooling follow their documented behavior.
    (#764)

  • Allocator and compiler caches preserve their contracts. Sanitizer pool
    metadata remains accessible while freed payloads stay poisoned. Cache keys
    include XLA thresholds, and AOT cache hits produce the requested object and
    bitcode outputs. (#770)

  • Imported names retain lexical scope. JIT batches resolve imported aliases
    through nested forms while preserving local bindings. Test gates record
    current expected outcomes and keep mutation verdicts separate from raw exit
    codes. (#761)

  • Example outcomes are bound to their measured sources. The catalogue
    records native JIT and AOT outcomes for all 67 programs. All 46 mathematics
    programs ran in both modes; 45 emitted their explicit all-pass result and
    the group-cohomology sweep completed successfully. Published constructions,
    arithmetic and finite computation limits are documented alongside them. (#755)

  • Public documentation covers the release's implementation and interfaces.
    Guides, language reference, architecture and vision documents, test-harness
    instructions and the paper artifact describe the current implementation.
    Fixed-point, i128 and exact-accumulation APIs are documented and indexed;
    site figures agree with the committed browser artifacts. (#753, #754, #756,
    #757, #758, #759)

  • XLA tensor results follow the active thread's region. The XLA runtime
    receives the current arena, and compiled run-cache entries include the GPU
    dispatch threshold. Elementwise outputs avoid redundant zeroing; large-block
    reuse preserves heap-limit enforcement. Coherent CUDA devices can use host
    operands directly, with an explicit pinned-path override. The XLA CI lane
    runs the region, cache and pool regressions. (#751, #752)

  • Full release CTest runs with four workers. The complete inventory,
    per-test limits and source-bound receipts are retained. Source-mutating ABI
    controls and timing-sensitive calibration checks remain serial. (#752)

  • ABI inventory includes the integrated contributor sites. Exact reviewed
    accessor and test-allocator counts are recorded without relaxing other
    lexical or semantic counts or negative controls. (#752)

  • Native AOT linking preserves the configured C++ driver name. A
    clang++ symlink retains C++ runtime and exception linking instead of being
    invoked through its clang target. (#750)

  • Outside-contributor CUDA tooling supports Linux ARM64 builds and reports.
    CUDAARCHS is honored, CUDA Docker builds expose toolchain/architecture
    arguments, and Linux fingerprints use the configured LLVM and BLAS. Ozaki
    reports distinguish dispatched CUDA kernels from vendor-BLAS fallback and
    separate measured errors from the implementation bound. They do not certify
    bit-exact CUDA results. (#732, #750)

  • Generated constructors and exception handlers check allocation failures.
    Cons, vector and closure construction, selected collection/parallel/FFT
    paths, captured environments and handler frames refuse incomplete results
    rather than dereferencing failed allocations. Dedicated failure-injection
    and IR controls cover this constructor/handler tranche. (#721)

  • ESKM v2 is available as a doubly gated hosted experiment. The source
    includes bounded, transactional readers and atomic writers with cross-engine
    compatibility checks. Ordinary packaged builds remain v1; the experiment
    requires a build option and process opt-in. Metadata is validated then
    discarded, bounded native destinations refuse v2, and stable public v2 APIs
    remain a separate design decision. (#722)

  • Unsupported native main signatures produce a compiler diagnostic.
    Fixed/rest-argument entries are refused before an invalid LLVM call is
    generated. File JIT preserves the real nullary entry across symbol renaming,
    including collisions with a user procedure named scheme_main. Native AOT
    exit status, library compilation and VM top-level execution retain their
    respective contracts. (#724)

  • Browser startup and exact numeric consumers share a checked runtime. The
    LLVM/WASM host preserves finite doubles as their exact integer or rational
    values through arithmetic, comparisons, rounding, roots and formatting.
    number->string preserves signed zero and readable nonfinite forms;
    unsupported complex and exact Taylor paths refuse explicitly. This restores
    site startup for the corrected example guides. Generated API pages distinguish
    compile-time statements from callable declarations and retain scoped methods,
    grouped declarators and initialized variables. (#744)

  • Release browser tests require a working hardware GPU environment. The
    workflow provisions pinned Playwright and verifies device readback before
    building. Linux Chrome uses an isolated X11 display with native Vulkan, and
    the live browser gates reject software adapters. Independent Python and
    browser setup steps run in parallel and join before the build. The complete
    value-position sweep retains every case and per-case limit, with an overall
    budget based on measured runner throughput. (#745)

  • Release evidence reports configured expected failures explicitly. The
    output audit uses the captured CTest inventory to distinguish existing
    expected-failure acceptance cases from ordinary passing tests. It retains
    their original output and still rejects ordinary false passes. (#746)

  • Release qualification separates complete coverage from full measurements.
    Sequential steps retain every traced-suite, CTest and VM check within the
    workflow's step limits. Coverage alone cannot produce a complete baseline
    or publication proof; source, workflow-attempt and binary binding remain mandatory. (#749)

  • SHA-256 and HMAC consume complete UTF-8 inputs. Crypto wrappers use byte
    lengths for both data and HMAC keys, with independent reference vectors for
    ASCII, multibyte and supplementary Unicode inputs. (#748)

  • Output-string ports can be closed and reused safely. Closing a stream
    retires its buffer and registry slot before its address can be reused.
    Snapshots remain independent, and repeated open/close cycles no longer
    exhaust a lifetime limit or return an earlier stream's text. (#748)

  • Example documentation follows the implementations. The catalogue covers all
    67 programs, including 46 mathematics examples, with algorithms, arithmetic,
    executable checks, prerequisites and limits. Navier–Stokes registration is
    derived from its 12 programs, 14 criteria and 28 native JIT/AOT entries. (#742)

  • Publication requires complete source-bound measurements. The release gate
    validates full configured CTest and VM parity results against committed
    metadata and the exact source, workflow run and build cohort. Deleting an
    evidence-status marker cannot qualify a release for publication. (#742)

  • Native REPL input stays clean across line-editing backends. Pipes and
    machine mode use one noninteractive reader whether readline is available or
    absent; interactive sessions retain their prompts. (#737)

  • Release builds require native image I/O. Every package and readiness
    configuration requires a native backend; configuration fails if none is
    selected. Developer builds retain the optional backend setting. (#737)

  • CUDA GEMM loads cuBLAS on demand. In CUDA-enabled builds, native, JIT,
    and VM programs load cuBLAS only when GPU GEMM needs it. Programs without
    GEMM can keep using other CUDA kernels without cuBLAS; a missing or
    incompatible library leaves GEMM on the CPU fallback. (#740)

  • Mixed exact/inexact interval arithmetic preserves containment in the
    confirmed cases.
    Exact endpoints are converted outward before arithmetic;
    indeterminate non-finite endpoint cases fail closed. (#727)

  • AOT loop memory reclamation covers the confirmed shapes: named-let exit,
    a discarded numeric tensor, and direct literal tensor-dot. This does not
    establish flat RSS for every loop or platform; the gate covers the direct
    literal form, while other tensor-dot forms remain outside this claim. (#729, #735)

  • Release evidence follows its source identity. The ICC release guard binds
    evidence to the exact checkout and commit SHA. VM parity traces honor the
    configured TRACE_DIR and are bound to the release cohort.