100% Emacs Lisp core, 1+5+2 extensions, four-target reach.

Value model

Implemented forms & 1+5+2 extensions

Compile-time & checked macros

(defmacro-checked once (form)
  `(let ((value$ ,form)) value$))

(defun load-once (value)
  (once (+ value 1)))

defmacro and cl-defmacro definitions are processed in source order and removed before emission. Backquote, comma, ,@, &optional, &rest, and &body are supported. defmacro-checked enforces a pure compile-time sandbox that statically rejects side-effecting IO, process, network, or file mutations during macro expansion.

ECMAScript modules & lexical defmodule

(import "eliscript/runtime/core/order" sort)
(import "react" :default React useState)
(import "library" :as Library)
(import "side-effect-only")

(export Component helper)
(export-default Component)

One Eliscript source file emits one ESM file. Alongside file-level (module ...), the eliscript-module extension provides (defmodule name (:export ...) (:import ...) ...) with lexical-private internal bindings (inaccessible externally while exposed to exported functions) and defvar-once hot-reload state preservation. Package subpath imports under eliscript/* support both extensionless specifiers (such as "eliscript/runtime/core/order" or "eliscript/runtime/emacs-compat") and explicit .mjs specifiers across Node, Bun, and the browser compiler. The repository itself tracks zero .mjs source files in Git; all JavaScript modules are synthesized from .eli sources during bootstrap.

Persistent collections

All collection families participate in value equality, hashing, metadata, canonical data text, generic lookup, reduction, construction, stack, and reversible traversal protocols where applicable, with structural reference-identity (===) short-circuiting for shared subtrees and compact O(1)-step persistent Vector Zipper navigation across 12,000+ levels without prefix array copying. Records extend persistent Map behavior without surrendering their declared type identity.

Owner-token Transient Vector, Map, and Set builders support efficient isolated construction. persistent! completes the builder once; later mutation or reuse is rejected, and static compiler analysis prevents transient ownership from escaping trusted construction scopes.

Portable sequences

(import "../../stdlib/sequence.eli" map filter reduce range)

(map (lambda (value) (* value 2)) (range 1 5))

The standard library is written in Eliscript and includes persistent hash and AVL-sorted collections, protocols, replayable and memoized lazy sequences, pull transduction, immutable tree rewriting and zipper editing, text, numeric, Result, JSON, state, and host-interop modules without adding application-framework dependencies.

The maintained stdlib/core/seq.eli and runtime/core/sequence.eli modules are authored in Eliscript. They accept persistent, native, and externally extended reducible values through collection protocols, return persistent Vectors, add remove, and combine O(1) / O(log32 n) indexed fast-paths for first, last, and nth with unboxed early termination for find and circular array ring buffers with transient Vector builders for take-last and drop-last.

Portable text

(import "../../stdlib/text.eli" contains? strip-prefix trim)

(trim (strip-prefix "#" "# article "))

Thirteen functions provide literal matching, end-exclusive slicing, prefix and suffix removal, ASCII-boundary trimming, blank checks, joining, and repetition. They are written in portable Eliscript without regular expressions or host string methods. Indices follow ECMAScript UTF-16 code units rather than locale-aware grapheme clusters.

Immutable objects

(import "../../stdlib/object.eli" assoc pick)
(import "../../stdlib/data.eli" index-by)

(pick (assoc (object :name "Eliscript") :runtime "JavaScript")
      [:name :runtime])

Eleven object functions enumerate own keys, test own properties, associate without mutation, remove and merge keys, transform values, and select fields. The data module adds keyed lookup, grouping, and counting by importing object primitives through explicit import-portable edges. Graph-aware portable builds verify those targets and prune every generated module.

The runtime-backed stdlib/core/data.eli and stdlib/core/order.eli surfaces return value-semantic persistent Maps and persistent Vector groups, add frequencies, sort, and sort-by, and use transient HAMT and Vector builders to eliminate intermediate persistent path copying.

Recursion and constant stack

(defun sum-to (n total)
  (if (= n 0)
      total
    (recur (1- n) (+ total n))))

recur is checked at compile time and lowers self recurrence or a lexical loop to an iterative transfer with constant JavaScript stack use. The standard-library trampoline runs returned zero-argument thunks and supports open or mutual recursion with a fixed stack.

100% Emacs Lisp core & 1+5+2 architecture

• 100% Emacs Lisp default core (eliscript-compat): Preserves Lisp-2 dual function/value namespaces, nil-only falsiness, lexical and dynamic defvar scope, mutable native containers alongside 7 persistent collection types, integer division (/ 7 2) => 3, condition-case / define-error, and full defmacro / cl-defmacro / pcase compatibility.
• 7 explicit extension packs (1+5+2): Activated by definition form without polluting standard Emacs Lisp — eliscript-contract, eliscript-data, eliscript-bind, eliscript-module, eliscript-async, eliscript-js, and eliscript-abi.
• Four-target ABI execution: Functions annotated with (declare (eliscript-abi :numeric-f64 ...)) or (declare (eliscript-abi :memory-u32 ...)) execute with identical semantics across Emacs Lisp, JavaScript ESM, WASM, and ARM64 Native binaries.
• Standalone .eli ESM modules: Keep lexical Lisp-1 resolution, immutable persistent literals [...] / {...} / #{...}, and explicit ECMAScript module boundaries.