Milestones
Vertical slice
Reader, core forms, deterministic ESM, CLI, snapshots, and Bun execution.
Language core
Macros, locations, analysis, explicit IR, direct emission, source maps, CLI, and runtime execution.
Browser validation
Optional React and Vite integrations verify emitted ESM, source maps, browser mounting, and live development without entering the compiler core.
Publishing validation
Pure Emacs Org export and a custom site verify that replaceable applications can consume deterministic Eliscript modules.
Bootstrap
The portable compiler driver, Bun adapter, complete conformance suite, and reproducible compiler fixed point.
Emacs acceleration
Portable functions, the resilient worker, source-mapped diagnostics, immutable module caching, segmented benchmarks, and an asynchronous indexing workload.
Standard library
Portable sequence, text, immutable object, and keyed data-indexing operations, real source imports, and a pure Emacs project builder that emits complete source-mapped ESM trees.
Contract baseline
Specification, evidence, public-surface, compatibility, diagnostics, and supported-platform contracts are versioned and executable.
Language closure
Persistent values, stable ESM imports, explicit host interop, stack-safe loop/recur, deterministic generated names, and declared digest-tracked macro file inputs complete the language contract.
Compiler convergence
Self-hosted graph planning, canonical IR and reports, deterministic incremental cache, Bun plus Node hosts, and versioned multi-entry public operations complete compiler convergence.
Daily development
The formatter, Emacs mode, project diagnostics, persistent evaluation, terminal REPL, host-neutral watch, and verified onboarding workflow are complete.
Data and libraries
Persistent collections, protocols, transducers, 43 standard-library modules with 584 checked exports, and explicit platform capabilities are complete and stabilized.
Reliability
The 100,000-input fuzz corpus, 1,000-module scale suite, 100,000-request Emacs worker soak, security matrix, performance budgets, and repository-integrity audit are complete.
Core acceptance
All 42 implementation units, 35 mandatory verification criteria, and 173 compatibility stabilization units are complete in the retained evidence.
The 1.0 maturity target
Eliscript aims to be a stable, self-hosted, Emacs-first functional Lisp for standard ECMAScript modules and portable high-performance Emacs workloads. Maturity means stable semantics, an authoritative self-hosted compiler, dependable project tools, a first-class Emacs workflow, proven host integration, and engineering evidence that can be reproduced.
Vite, React, publishing, blogs, sites, hosting, and development servers are replaceable application validation only. They do not define core goals, dependencies, semantics, or maturity credit.
The evidence-derived construction plan is defined in specification 0040. Explicit implementation units, acceptance criteria, dependencies, and exit gates decide completion.
A stronger data model
Eliscript keeps JavaScript directly reachable while making immutable persistent collections the default composite values. Lists use linked nodes, Vectors use a 32-way bit-partitioned trie with a tail, Maps and Sets use a HAMT, Queues compose persistent Vectors, and sorted collections use structurally shared AVL trees.
Focused protocols define counting, lookup, association, traversal, reduction, equality, hashing, and transient construction. Transducers compose collection transformations without allocating intermediate arrays. Native JavaScript arrays and objects remain explicit interop types with shallow and deep conversion.
The goal is host symbiosis: improve JavaScript's programming model without hiding its libraries or runtime. The complete algorithms, complexity targets, migration steps, and structural acceptance checks are in specification 0041.
Bootstrap chain
Generation 0
Emacs Lisp seed + program.eli → program.js
Generation 1
Emacs Lisp seed + compiler.eli → compiler.js
Generation 2
compiler.js + compiler.eli → next-compiler.jsBoth compiler generations pass the same conformance suite, and the generated compiler reproduces itself without semantic drift.
Generation 1 builds Generation 2, and Generation 2 builds the same Generation 3. All ten ESM modules and all ten Source Maps match byte-for-byte.
A path back into Emacs
Emacs now controls a long-lived Bun worker over versioned NDJSON while retaining editor state and interaction. Requests support progress, cooperative cancellation, timeouts, whole-graph manifests, dependency-aware mapped Eliscript errors, immutable module versions, and automatic worker generations.
defportable rejects mutable module state and host interop, follows immutable helper dependencies transitively, and emits a frozen manifest that the worker resolves by Eliscript source name. Verified project metadata now reuses clean modules while dirty portable graphs repeat closure validation before emission. Versioned build reports expose stable cache decisions and separate non-identity phase timings to editors and CI. A document-search adapter compiles its scoring closure with a source map and dispatches documents concurrently.
The mature API adds persistent-value encoding, chunked transfer, dual Emacs Lisp and Eliscript implementations, verification mode, workload thresholds, buffer-version guards, and transactional result application. Editors keep identity-sensitive work in Emacs; parsers, transforms, indexing, graph analysis, and other coarse-grained computations can use a warm JavaScript engine.
The reference workload measured a much larger engine-only speedup than end-to-end speedup because transport and client work remain visible. Coarse-grained tasks are the target; small editor operations stay in Emacs.
Final acceptance is all or nothing
The retained maturity target records AC-01 through AC-24 and PD-01 through PD-11 passing in one clean, traceable run. The gate covers stable semantics, seed and self-hosted parity, reproducible bootstrap, deterministic projects, formatter and Emacs mode behavior, source-level debugging, persistent collection correctness and structural bounds, host portability, fuzzing, scale, security, worker soak, and documentation.
Two maintained Emacs analysis workloads each exceed the required 2x median warm end-to-end speedup over equivalent Emacs Lisp implementations across 30 runs. The evidence includes persistent collections and transducers, and measures the complete transport and client path rather than engine-only timing.
The current canonical report retains 35/35 passing criteria and no blocking defects. That result belongs to its recorded source identity; a changed revision must refresh its compatibility evidence before making the same host-matrix claim.
The next frontier
General automatic tail-call optimization is now tracked by specification 0180. Direct self-tail calls and closed mutual-recursion groups are separate candidates. Both must preserve argument evaluation, arity, destructuring, exceptions, async ordering, Source Maps, interoperation, and compiler parity.
Until that Draft becomes an implemented and stabilized contract, explicit recur remains the preferred self-recursion mechanism and trampoline remains the mechanism for dynamic or mutual thunk chains.
Principles that stay fixed
- Emacs remains enough to build the seed compiler.
- Generated code stays readable and standards-based.
- JavaScript interop is explicit rather than magical.
- Persistent immutable values are language defaults; mutable host containers are explicit.
- Compatibility never blocks a clearly better language design.
- Self-hosting is proven by reproducibility and conformance, not branding.
- Performance claims include the complete Emacs-to-worker round trip.