EGCL v0.0.1

Changelog

0.0.1 - 2026-10-04

This release establishes the first versioned baseline of Evergreen Common Lisp
(EGCL). EGCL is an experimental Common Lisp implementation built from scratch
in Rust. It is intended to explore a practical Lisp runtime with adaptive
native compilation, a moving collector, lightweight concurrency, and
application delivery. It targets ANSI Common Lisp, but 0.0.1 does not claim
complete conformance, compatibility stability, or production readiness.

Execution model

• The reader, macro expander, and compiler lower supported Lisp forms to T0
  bytecode. A tree-walking evaluator remains available for bootstrap and
  compatibility paths.
• Repeatedly called functions can advance from T0 to baseline native T1 and
  optimized native T2 code. Unsupported target or operation shapes remain at a
  lower tier.
• Hot loops can enter native code during the current invocation through
  on-stack replacement (OSR).
• T2 can specialize dynamically typed operations under guarded assumptions.
  Failed guards deoptimize to a less specialized execution point while
  preserving live values and effects already performed.
• Functions remain redefinable while the program runs. Installed native code,
  OSR code, and older active definitions retain separate metadata and
  lifetimes.

Common Lisp and runtime

• The implemented language includes the reader, packages, macros, lexical and
  dynamic binding, closures, multiple values, non-local control transfer,
  CLOS, conditions and restarts, streams, sequences, hash tables, pathnames,
  printing, and FORMAT. Coverage remains incomplete and is tracked by the
  specification and conformance suites.
• ASDF is included in saved distribution images. COMPILE-FILE produces EGCL's
  portable BFASL format for supported code, and ASDF systems can compile and
  load through the normal Lisp interfaces.
• A precise, moving generational garbage collector traces interpreted,
  bytecode, native, foreign-call, thread, and fiber roots. Stress and poison
  modes are part of runtime validation.
• Native threads provide joins, mutexes, condition variables, thread-local
  bindings, safepoints, and GC coordination.
• Stackful fibers multiplex Lisp executions over native carrier threads and
  can suspend and migrate on supported targets. Established TCP stream reads,
  writes, and readiness waits can park an unpinned fiber; connect, accept, and
  DNS operations are not yet cooperative.

Interoperability and delivery

• The foreign function interface loads shared libraries, calls C functions,
  supports callbacks, and manages foreign memory. ABI coverage differs by
  architecture; x86-64 has the broadest call-shape support.
• The native x86-64 glibc distribution includes egcl-jvm, with JVM startup,
  Java calls, named bindings, Lisp implementations of Java interfaces,
  reference scopes, and shutdown. Builds configured with Python support expose
  the Lisp-facing PY CPython API.
• A running Lisp environment can be saved as a core image or appended to an
  executable. Images record runtime compatibility requirements and are tied to
  their architecture and runtime capabilities.
• Delivery can remove unreachable Lisp objects, functions, macros, methods,
  compiler tiers, builtin implementations, disassembly support, and the tree
  walker. A specialized delivered runtime can retain T0 only, T0+T1, or all
  three tiers.
• The Android tooling creates Makefile-based NativeActivity projects for ARM64
  devices and x86-64 emulators, including minimal and EGL/OpenGL ES templates.

Debugging and observability

• Interactive errors enter a debugger with restarts, backtrace display, frame
  selection, frame evaluation where metadata permits, and stepping commands.
  Batch errors exit without waiting for terminal input.
• Lisp backtraces cover tree-walked, T0, native T1/T2/OSR, fiber, and outbound
  foreign-call boundaries. Historical error snapshots retain frames before
  unwinding; original arguments are reported when they have a proven stable
  location.
• Installed native code carries in-memory ELF/DWARF metadata for generated
  function names, machine-code ranges, and recoverable fixed-arity argument
  homes. Supported Linux builds register generated code through GDB's JIT
  interface.
• The runtime exposes disassembly, tier observations, event profiling,
  allocation profiling, GC statistics, tracing, and breakpoint/watchpoint
  primitives.

Platforms and packages

• Runtime targets include Linux x86-64, AArch64, ppc64le, and s390x; Windows
  x86-64; and Android ARM64, with Android x86-64 application libraries. Native
  compiler, FFI, and validation coverage varies by target.
• The Fedora 44 x86-64 package set contains the native glibc runtime, a static
  musl runtime, glibc and static image-dumping tools for AArch64, ppc64le, and
  s390x, a Windows image-dumping tool, and Android CLI/application tooling.
• The same source RPM can build native glibc and static packages on ppc64le.
  Those POWER-native RPMs are not published as 0.0.1 assets because the release
  service does not yet provide the native OpenJDK required by that builder.
  Cross runtimes are executed under QEMU or Wine during package validation;
  packaged payloads are extracted and checked again for architecture, ASDF,
  dump/restart, and GC-stress behavior.
• Saved applications and target tools are documented in the
  manual. The current support matrix is in
  Platform support.

Known boundaries

• EGCL remains under active development. ANSI coverage, diagnostics,
  performance, and behavior across tiers and targets are not yet uniform.
• Source lines, inline scopes, complete local-variable recovery, DWARF unwind
  rules, full native C-stack unwinding, and capture of a concurrently running
  fiber are not complete. Optimized, overwritten, variadic, and register-only
  arguments may be unavailable in a backtrace.
• Foreign aggregate arguments are not portable across every target, and some
  non-x86 native backends support fewer optimized operations than x86-64.
• Heap images are architecture-specific. Dynamic target executables require a
  compatible system ABI, while static runtimes cannot provide every dynamic
  integration feature.
• The project specification is staged. Version 0.0.1 establishes the S5
  HotSpot-engine baseline: promoted code, OSR, and deoptimization must preserve
  results. Later specification stages remain future work.

EGCL test-v0.0.1-37127390819-1

Changelog

0.0.1 - 2026-10-01

The initial experimental release of Evergreen Common Lisp (EGCL). This version
establishes the starting point for a Common Lisp implementation with a tiered
JIT runtime and standalone application delivery.

• A reader and evaluator, macros, CLOS, conditions and restarts, and ASDF
  integration.
• Bytecode execution, baseline and optimizing native compilation, on-stack
  replacement, and deoptimization for supported operations.
• Precise generational garbage collection, native threads, and stackful fibers.
• Saved images and standalone executables, with application tree shaking.
• C interoperability and optional JVM and CPython integration.
• Runtime ports for x86-64, AArch64, PPC64LE, and s390x, including Windows and
  Android support on selected targets.
• Fedora RPM packaging, Android application tooling, and a user and contributor
  manual.

EGCL is under active development. See the manual for
supported interfaces and platform limitations.

EGCL test-v0.0.1-37106465163-1

Changelog

0.0.1 - 2026-10-01

The initial experimental release of Evergreen Common Lisp (EGCL). This version
establishes the starting point for a Common Lisp implementation with a tiered
JIT runtime and standalone application delivery.

• A reader and evaluator, macros, CLOS, conditions and restarts, and ASDF
  integration.
• Bytecode execution, baseline and optimizing native compilation, on-stack
  replacement, and deoptimization for supported operations.
• Precise generational garbage collection, native threads, and stackful fibers.
• Saved images and standalone executables, with application tree shaking.
• C interoperability and optional JVM and CPython integration.
• Runtime ports for x86-64, AArch64, PPC64LE, and s390x, including Windows and
  Android support on selected targets.
• Fedora RPM packaging, Android application tooling, and a user and contributor
  manual.

EGCL is under active development. See the manual for
supported interfaces and platform limitations.

EGCL test-v0.0.1-37026037520-1

Changelog

0.0.1 - 2026-10-01

The initial experimental release of Evergreen Common Lisp (EGCL). This version
establishes the starting point for a Common Lisp implementation with a tiered
JIT runtime and standalone application delivery.

• A reader and evaluator, macros, CLOS, conditions and restarts, and ASDF
  integration.
• Bytecode execution, baseline and optimizing native compilation, on-stack
  replacement, and deoptimization for supported operations.
• Precise generational garbage collection, native threads, and stackful fibers.
• Saved images and standalone executables, with application tree shaking.
• C interoperability and optional JVM and CPython integration.
• Runtime ports for x86-64, AArch64, PPC64LE, and s390x, including Windows and
  Android support on selected targets.
• Fedora RPM packaging, Android application tooling, and a user and contributor
  manual.

EGCL is under active development. See the manual for
supported interfaces and platform limitations.