# Changelog

> Release notes for every Elide version, newest first: what was added, changed and fixed in each release, with links to its GitHub release.

Releases are listed newest first; select a version to expand it.

<div class="changelog-meta">
  <span>Latest release <code>1.6.2</code></span>
  <span>For install and upgrade commands, see <a href="https://elide.help/docs/releases">Releases</a>.</span>
</div>

## Inside Elide 1.6.3

Elide 1.6.3 expands the project toolchain with Android builds, Micronaut integration, shared test services, and Python package tools. It also adds Maven version overrides, richer build telemetry, and commands for reading Markdown and rendering configuration. This release is in development; 1.6.2 remains the latest release.

### Build and run an Android app

Create a Kotlin Compose app with the Android template, then build a signed development APK. Elide also builds AAR libraries and app bundles, merges workspace resources and manifests, and supports optional code shrinking. The Compose compiler is opt-in through `kotlin.features.compose`; the template enables it and declares the runtime dependencies.

Install an Android SDK before starting. Elide reports missing SDK components and the commands to install them. Run the following in a new directory; the keystore task creates a development signing key once. The run task installs and launches the app on an attached device, or starts the configured emulator.

Use `elide build android-debug-app` to launch suspended and print the forwarded debugger address. Android testing supports configured host tests and instrumented test APKs; an instrumented test APK needs its own project. App bundles with dynamic feature modules cannot yet be minified.

**Create and launch the app**

```shell
mkdir hello-android
cd hello-android
elide init --template android --plain --skip-defaults -- package=com.example.hello
elide build android-keystore-app
elide build app
elide build android-run-app
```

See [Compose compiler](https://elide.help/docs/toolchain/jvm/kotlinc#compose), [Android starter source](https://github.com/elide-dev/elide/tree/main/project/samples/android), [Android build guide](https://github.com/elide-dev/elide/blob/main/docs/android.md).

### Build Micronaut applications

Declare a Micronaut Core version and Elide installs the matching Java annotation and native metadata processors. Put application settings in `jvm.micronaut.config` to generate `application.json` on the classpath. Elide installs the JSON loader and rebuilds affected artifacts when configuration changes; authored resource files remain supported.

Create these two files in a new project directory. The program starts a Micronaut application context and reads the message from Pkl configuration. Run `elide install`, then `elide run`; it prints `Hello from Pkl`.

Use the Micronaut Core version, which can differ from the platform BOM version. This integration processes Java sources; Micronaut processing through Kotlin KSP is not yet provided. The guide extends this example with JUnit tests, coverage, JVM distributions, and native executables.

**elide.pkl**

```pkl
amends "elide:project.pkl"
name = "hello-micronaut"

dependencies {
  micronaut {
    version = "4.10.23"
    modules { "runtime" }
  }
}
jvm {
  main = "example.Application"
  micronaut {
    config {
      sample { message = "Hello from Pkl" }
    }
  }
}
```

**src/main/java/example/Application.java**

```java
package example;

import io.micronaut.context.ApplicationContext;

public final class Application {
  public static void main(String[] args) {
    try (var context = ApplicationContext.run()) {
      System.out.println(context.getRequiredProperty("sample.message", String.class));
    }
  }
}
```

See [Micronaut guide](https://elide.help/docs/toolchain/jvm/micronaut), [Testing and coverage](https://elide.help/docs/toolchain/testing), [Native packaging](https://elide.help/docs/toolchain/jvm/native-image).

### Share a service across test runners

Declare databases and other test services in `testing.testcontainers`. Elide starts them once for the project, waits for readiness, and gives JavaScript, TypeScript, and JUnit tests the same connection settings. Host ports are allocated dynamically, so concurrent runs need no fixed port reservations.

This example starts an HTTP service and tests its response. Save both files in a new project directory and run `elide test`. A Docker-compatible daemon and JDK 17 or newer are required. Java and Kotlin tests can read the same `TEST_URL` with `System.getenv("TEST_URL")`.

Startup failures fail the test run. Containers are cleaned up after success, failure, or cancellation; installation and compilation alone do not start them. Container tooling stays out of application dependencies.

**elide.pkl**

```pkl
amends "elide:project.pkl"
name = "service-tests"

testing {
  testcontainers {
    containers {
      ["web"] {
        image = "busybox:1.37"
        command {
          "sh"; "-c"
          "mkdir -p /www; echo ready > /www/index.html; httpd -f -p 8080 -h /www"
        }
        ports { 8080 }
        wait { strategy = "http"; port = 8080 }
      }
    }
    environment {
      ["TEST_URL"] = "http://${web.host}:${web.port.8080}/"
    }
  }
}
```

**service.test.ts**

```typescript
import test from "node:test";
import assert from "node:assert/strict";

test("service is ready", async () => {
  const url = process.env.TEST_URL;
  assert.ok(url, "TEST_URL must be supplied by the test runner");
  const response = await fetch(url);
  assert.equal(response.status, 200);
  assert.equal((await response.text()).trim(), "ready");
});
```

See [Container configuration](https://elide.help/docs/toolchain/testing#shared-test-containers), [JavaScript and JUnit sample](https://github.com/elide-dev/elide/tree/main/project/samples/testcontainers).

### Install Python packages and run console tools

Python package tooling is available on demand with the optional Python component. `elide uv install` adds packages to the project environment, which Elide loads without activation. `elide uv tool run` uses a separate environment for a console tool, keeping its dependencies out of the project.

Create the manifest below in a new directory, then install a package and run a tool. The HTTPie command prints help; it does not send a request. Tool environments are cached between runs; `elide uv tool list` shows them and `elide uv tool prune` removes expired or excess entries.

Python remains experimental. Package installation supports compatible wheels only; source builds and arbitrary CPython native extensions are not supported. `elide uv` exposes the documented package and tool commands, not the full upstream command set. Python tests still run through `elide python -m unittest` or an installed pytest, rather than `elide test`.

**pyproject.toml**

```toml
[project]
name = "python-demo"
version = "0.1.0"
requires-python = ">=3.13"
```

**Install a package and run an isolated tool**

```shell
elide setup python
elide uv install attrs
elide python -c 'import attrs; print(attrs.__version__)'
elide uv check
elide uv tool run --from 'httpie==3.2.4' http --help
elide uv tool list
```

See [Python packages and tools](https://elide.help/docs/python-packages), [Python toolchain](https://elide.help/docs/python-toolchain).

### Select one Maven version across the dependency graph

Use `dependencies.maven.resolutions` when a direct or transitive dependency needs a specific version. Each key is a `group:artifact` pair, and the override applies before dependency metadata is fetched, including requests for other classifiers or packaging types.

In this example, the resolution selects Commons Lang 3.20.0 even though the direct dependency requests 3.19.0. Run `elide install` after changing the manifest. An override does not add a missing dependency or restore an excluded one.

Values must be exact versions; ranges and wildcards are rejected. Workspace members inherit root overrides and can replace them by key. Changing or removing an override invalidates the resolved dependency graph.

**elide.pkl**

```pkl
amends "elide:project.pkl"
name = "version-overrides"

dependencies {
  maven {
    packages { "org.apache.commons:commons-lang3:3.19.0" }
    resolutions {
      ["org.apache.commons:commons-lang3"] = "3.20.0"
    }
  }
}
```

See [Maven version overrides](https://elide.help/docs/toolchain/dependencies#maven-version-resolutions).

### Follow a build from tasks to test results

With an OTLP destination configured, build and test commands export correlated spans for tasks, execution units, and individual tests. An invocation ID ties each report together, with task outcomes and cache status attached. In your collector, find the `elide.build` or `elide.test` root span and inspect its children.

Run these commands in an existing project with an OTLP/HTTP collector listening on port 4318. Global telemetry flags go before the command. Without a configured destination, no build or test telemetry is exported; there is no separate build-report flag.

Automatic HTTP server telemetry also gains active-request and body-size measurements, and runtime instrumentation logs retain structured fields and trace context in OTLP export. Guest CPU profiles remain experimental and require separate configuration.

**Send build and test traces to a local collector**

```shell
elide --otel-endpoint=http://localhost:4318 --otel-protocol=http/protobuf build
elide --otel-endpoint=http://localhost:4318 --otel-protocol=http/protobuf test

# Disable telemetry for one invocation, even if the project enables it.
elide --no-otel test
```

See [Build and test reports](https://elide.help/docs/opentelemetry/runtime#enable-build-reports), [Telemetry configuration](https://elide.help/docs/opentelemetry/configuration).

### Generate JSON or YAML from configuration

Evaluate `.pkl` or `.pcf` files directly and render the format your application expects. No Elide project is required. Relative imports resolve from the input file, so configuration can share nearby defaults.

Save the configuration below as `config.pkl`. The JSON command writes `service`, `port`, and `healthPath` with the same values and types; the YAML command renders the same configuration in YAML. Without `--format`, the module controls its output, with PCF as the default.

Rendered content goes to stdout; diagnostics go to stderr. Use `--out config.json` to replace a file atomically after successful evaluation, or `--out -` to explicitly select stdout. TOML output is not supported.

**config.pkl**

```pkl
service = "api"
port = 8080
healthPath = "/health"
```

**Render the configuration**

```shell
elide --format=json config.pkl
elide --format=yaml config.pkl

# Replace a generated file only after successful evaluation.
elide --format=json --out config.json config.pkl
```

See [Pkl rendering guide](https://elide.help/docs/pkl-configuration).

### Read READMEs and runbooks in the terminal

Open a `.md` or `.markdown` file to read headings, lists, tables, and highlighted code blocks with terminal-width wrapping. Task lists and strikethrough are supported. No project manifest is required.

Use an existing README or runbook with the commands below. Piped output is plain, links retain their destinations, and raw HTML is shown as text. Code examples are displayed without execution.

**Read an existing document**

```shell
elide README.md
elide docs/runbook.md | less
elide --no-color README.md > readme.txt
```

See [Terminal Markdown guide](https://elide.help/docs/terminal-markdown).

## Releases

<div class="changelog-timeline">

  <details class="cl-release cl-release-current" open>
    <summary><span class="cl-release-version" role="heading" aria-level="3">1.6.3</span> — Next release</summary>
    <div class="cl-release-body">
      <p>Android builds and Compose, Micronaut applications, shared test containers, Python package tools, Maven version overrides, and terminal document rendering.</p>
      <div class="cl-changes">
        <section class="cl-change" data-kind="added">
          <span class="cl-change-tag">Added</span>
          <ul class="cl-change-list">
            <li>Build Android APKs, AAR libraries, and app bundles from <code>elide.pkl</code>. The Android template includes a Kotlin Compose app; device tasks install, run, debug, and test it using an installed Android SDK.</li>
            <li>Enable the Compose compiler with <code>kotlin.features.compose = true</code> or <code>elide kotlinc --compose</code>. Declare a compatible Compose runtime dependency; the compiler plugin remains off by default.</li>
            <li>Declare Micronaut Core dependencies and Elide installs matching Java annotation processors. Configure the application in Pkl or resource files, run JUnit tests with coverage, and package JVM applications or native executables.</li>
            <li>Declare shared test services in <code>testing.testcontainers</code>. JavaScript, TypeScript, and JUnit tests receive the same container connection settings, with readiness checks and cleanup after the run.</li>
            <li>Install Python packages into the project environment with <code>elide uv install</code>, or run console tools in isolated environments with <code>elide uv tool run</code>. Requires the optional Python component; only compatible wheels are supported.</li>
            <li>Override direct and transitive Maven versions with <code>dependencies.maven.resolutions</code>. Workspace members inherit root overrides and can replace them by module.</li>
            <li>Export build tasks and test results as correlated OpenTelemetry spans, with invocation IDs, task outcomes, and cache status. Export requires a configured telemetry destination; guest CPU profiles remain experimental.</li>
            <li>Render <code>.pkl</code> and <code>.pcf</code> files as JSON, YAML, or PCF: <code>elide --format=json config.pkl</code>. Without <code>--format</code>, the module controls its output. No Elide project is required.</li>
            <li>Read Markdown with <code>elide README.md</code>: headings, lists, tables, task lists, and highlighted code blocks adapt to the terminal. Piped output is plain; code blocks are displayed without execution.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="changed">
          <span class="cl-change-tag">Changed</span>
          <ul class="cl-change-list">
            <li>Automatic HTTP server telemetry records active requests and request and response body sizes alongside request duration. Throughput counts include unsampled requests.</li>
            <li>Runtime instrumentation logs join the configured OpenTelemetry export, retaining structured fields and trace context. Runtime logging controls apply independently of application logging.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="fixed">
          <span class="cl-change-tag">Fixed</span>
          <ul class="cl-change-list">
            <li>Heap sizing respects Linux container memory limits instead of sizing against host RAM, avoiding oversized default heaps in memory-limited containers.</li>
            <li>Program arguments after <code>--</code> reach the program unchanged, including arguments that resemble Elide engine options.</li>
            <li>Builds preserve compiler arguments and generated sources for editor project synchronization.</li>
            <li>Android debugging lets <code>adb</code> allocate an available forwarded port, removing the race between choosing a port and opening it.</li>
            <li>Telemetry sidecar file descriptors are closed on exec on older glibc systems, so child processes no longer inherit them.</li>
          </ul>
        </section>
      </div>
    </div>
  </details>

<details class="cl-release">
    <summary class="cl-release-header">
      <span class="cl-release-heading">
        <span class="cl-release-version" role="heading" aria-level="3">1.6.2</span>
      </span>
      <span class="cl-release-summary">Embedded C compiler and linker via LLVM, Java bindings from C headers, dotenv and encrypted configuration, Java ABI jars, and dependency-aware formatting.</span>
    </summary>
    <div class="cl-release-body">
      <div class="changelog-release-links" aria-label="Release links for Elide 1.6.2">
        <a class="changelog-release-link" href="https://elide.help/docs/releases">
          <span class="changelog-release-link-label">Release notes</span>
          <code>1.6.2</code>
        </a>
        <a class="changelog-release-link changelog-release-link-github" href="https://github.com/elide-dev/elide/releases/tag/v1.6.2" target="_blank" rel="noopener noreferrer">
          <span class="changelog-github-icon"></span>
          <span class="changelog-release-link-label">GitHub</span>
          <code>v1.6.2</code>
        </a>
      </div>
      <p>The <a href="https://elide.help/docs/changelog#inside-elide-1-6-2">1.6.2 feature narrative</a> covers the workflows and links to complete guides.</p>
      <div class="cl-changes">
        <section class="cl-change" data-kind="added">
          <span class="cl-change-tag">Added</span>
          <ul class="cl-change-list">
            <li>Embedded C compiler and linker via LLVM: <code>elide cc</code> emits native objects or LLVM IR and links JIT code in memory to invoke a zero-argument <code>long long</code> function.</li>
            <li><code>elide jextract</code> generates Java FFM sources from C headers. Named Pkl binding groups and ad hoc <code>javac --jextract</code> headers also compile in memory with application sources; <code>--emit-bindings</code> exports generated sources for IDEs.</li>
            <li>Application commands load <code>.env</code> and <code>.env.local</code> defaults and Java properties from <code>.properties</code> and <code>.properties.local</code>. Explicit file lists and per-domain disable flags control discovery.</li>
            <li>Dotenv and Java properties accept dotenvx-compatible <code>encrypted:</code> values, with private keys from the inherited environment or selected directories&#x27; <code>.env.keys</code> files.</li>
            <li><code>elide javac --abi-only</code> emits Java header jars through Turbine; <code>--emit-abi</code> adds a header jar alongside a full compilation.</li>
            <li>jfmt resolves imports against project dependencies or an explicit classpath, supports source selections, and works with <code>elide format --install</code> to resolve dependencies first.</li>
            <li>Add build tasks written in JavaScript or TypeScript: modules listed under <code>extensions</code> in <code>elide.pkl</code> declare tasks with inputs, outputs, flags, groups, and ordering, cached like built-in tasks. <a href="https://elide.help/docs/toolchain/build-extensions">Build extensions</a></li>
            <li>Package an extension as a <code>.elx</code> archive with an <code>Extensions.ExtensionArchive</code> artifact.</li>
            <li>Fetch extensions with <code>url:</code>, <code>npm:</code>, or <code>maven:</code> declarations; <code>integrity</code> pins the downloaded bytes.</li>
            <li>Extension tasks call the embedded <code>kotlinc</code>, <code>javac</code>, <code>jar</code>, Native Image, ktfmt, and google-java-format in-process through <code>ctx.tools</code>.</li>
            <li><code>elide build &lt;task&gt; --help</code> describes the flags a task accepts.</li>
            <li>A flag an extension task declares decides whether the task is up to date and which cache entry it uses; <code>keyed: false</code> opts a flag out.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="changed">
          <span class="cl-change-tag">Changed</span>
          <ul class="cl-change-list">
            <li>Kotlin ABI-only compilation strips non-inline bodies by default while retaining inline bodies, metadata, and constants needed by downstream compilation.</li>
            <li>Generated native seams share invocation-scoped environment and property loading across native and JVM execution.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="fixed">
          <span class="cl-change-tag">Fixed</span>
          <ul class="cl-change-list">
            <li>jextract PCH serialization preserves the host runtime’s signal handlers, and split JVM tools resolve their run-context functions on Linux and Windows.</li>
            <li>Child JVMs, project tasks, and Node child processes respect filtered inherited environments instead of retaining denied OS variables.</li>
            <li>KSP and its Analysis API match the bundled Kotlin 2.5.0-Beta2 compiler, including native processor execution.</li>
            <li>The embedded Native Image driver initializes its option descriptors safely and preserves the project&#x27;s working directory.</li>
            <li>macOS telemetry delivers final runtime metrics, spans, logs, and profiles on process exit, with corrected sidecar startup and final-response handling.</li>
            <li>OTLP exports use configured CA files and directory lists in both the parent and export sidecar.</li>
            <li>Recursive macOS file watches retain nested filenames through symlink roots, and POSIX <code>os.hostname()</code> reads the host name without a DNS lookup.</li>
            <li><code>elide classpath --json main:compile test:compile</code> returns each query’s paths in a JSON object, restoring project synchronization for editor integrations that request batched classpaths.</li>
            <li>Package-private <code>#imports</code> resolve within the importing package, including conditional and wildcard targets, so packages such as OpenTelemetry SDK 3 load correctly.</li>
            <li>JavaScript and TypeScript test files retain their file origins, so relative ESM imports resolve under <code>elide test</code>.</li>
            <li>Standalone Java source launches preserve selected environment and property files and honor <code>--no-env</code> and <code>--no-properties</code> without rediscovering automatic files.</li>
            <li><code>elide -m MODULE</code> runs the Python module instead of opening the REPL and offers Python setup before engine startup when the component is missing.</li>
            <li>Native Image distributions retain the ONNX runtime, inference models, and adopted JDK profiles required by optimized builds, fixing ML profile-inference initialization failures.</li>
            <li>Invalid inbound <code>traceparent</code> values discard the accompanying <code>tracestate</code>, preventing it from leaking into child and outbound spans.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="chore">
          <span class="cl-change-tag">Maintenance</span>
          <ul class="cl-change-list">
            <li>Update the managed Elide and GraalVM toolchains, regenerate native seam bindings and dependency locks, and remove unused runtime and build helpers.</li>
          </ul>
        </section>
      </div>
      <p><a href="https://elide.help/docs/toolchain/native/cc">Embedded C compiler and linker via LLVM</a> · <a href="https://elide.help/docs/toolchain/native/jextract">jextract</a> · <a href="https://elide.help/docs/environment">Environment and properties</a> · <a href="https://elide.help/docs/toolchain/jvm/javac#abi-jars">Java ABI jars</a> · <a href="https://elide.help/docs/toolchain/jvm/formatting">Formatting</a></p>
    </div>
  </details>


  <details class="cl-release">
    <summary class="cl-release-header">
      <span class="cl-release-heading">
        <span class="cl-release-version" role="heading" aria-level="3">1.6.1</span>
      </span>
      <span class="cl-release-summary">Runs on glibc 2.17 and later, adds a static build for Alpine and other musl systems, moves to Kotlin 2.5.0-Beta2, and updates TLS, compression, and archive dependencies for security advisories.</span>
    </summary>
    <div class="cl-release-body">
      <div class="changelog-release-links" aria-label="Release links for Elide 1.6.1">
        <a class="changelog-release-link" href="https://elide.help/docs/releases">
          <span class="changelog-release-link-label">Release notes</span>
          <code>1.6.1</code>
        </a>
        <a class="changelog-release-link changelog-release-link-github" href="https://github.com/elide-dev/elide/releases/tag/v1.6.1" target="_blank" rel="noopener noreferrer">
          <span class="changelog-github-icon"></span>
          <span class="changelog-release-link-label">GitHub</span>
          <code>v1.6.1</code>
        </a>
      </div>
      <div class="cl-changes">
        <section class="cl-change" data-kind="added">
          <span class="cl-change-tag">Added</span>
          <ul class="cl-change-list">
            <li>A static <code>linux-amd64-musl</code> build runs on Alpine and other musl distributions. The install script picks it on musl and on glibc older than 2.17; <code>--libc=glibc</code> or <code>--libc=musl</code> overrides the choice.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="changed">
          <span class="cl-change-tag">Changed</span>
          <ul class="cl-change-list">
            <li>Linux builds for amd64 and arm64 need glibc 2.17 or later, down from 2.34: RHEL and CentOS 7, Amazon Linux 2, Ubuntu 20.04, Debian 11, and later.</li>
            <li>The musl build has no Python and ships no JDK or <code>native-image</code>: <code>elide java</code> uses an installed JDK, and <code>elide native-image</code> uses an installed GraalVM.</li>
            <li>Elide is no longer published to npm, and the <code>@elide-dev/elide</code> package is no longer updated; install with the install script or a package manager.</li>
            <li>Kotlin language and API levels below <code>2.2</code> fail with an error that names the flag and the bundled compiler's minimum, in <code>elide kotlinc</code> and in <code>elide.pkl</code> compiler options.</li>
            <li>HTTP serving removes dot segments from the request path, including encoded <code>%2e%2e</code>, before the handler sees it: <code>/../index.html</code> serves the site root's <code>index.html</code> instead of <code>404</code>. Paths still cannot leave the root.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="fixed">
          <span class="cl-change-tag">Fixed</span>
          <ul class="cl-change-list">
            <li><code>--timeout</code> always exits with <code>124</code>; a timed-out program could exit with <code>137</code>.</li>
            <li>The bundled <code>elide-api</code>, <code>elide-insight</code>, and <code>elide-rewrite</code> jars keep the same bytes from build to build, so a lockfile that pins them stays valid when they have not changed.</li>
            <li>The docs MCP server files reports sent as top-level fields or as a JSON string, and accepts a report without an Elide binary, such as a failed install, marked as needing evidence.</li>
            <li>Docs links without the <code>/docs</code> prefix, such as <code>/changelog</code>, redirect to the page they name.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="chore">
          <span class="cl-change-tag">Maintenance</span>
          <ul class="cl-change-list">
            <li>GraalVM 25.5.5-elide.20, with the blocked-certificate list updated for CVE-2026-91403.</li>
            <li>AWS-LC 5.11.0 for TLS and cryptography, in both the Rust crates and the Java security provider.</li>
            <li>Kotlin 2.5.0-Beta2 with kotlinx-serialization 1.12.0, Metro 1.5.0, and Pkl 0.32.2.</li>
            <li>SQLite 3.53.4 on Linux.</li>
            <li>Security updates: rustls 0.23.46 (RUSTSEC-2026-0346 to 0349), rustls-webpki 0.103.16 (RUSTSEC-2026-0382), webpki-root-certs 1.0.11 (RUSTSEC-2026-0383), ctutils 0.4.6 (RUSTSEC-2026-0385), tokio 1.54.1 (RUSTSEC-2026-0386), zstd 0.14.3 (RUSTSEC-2026-0391, 0395 to 0406, and 0410), and zip 9 (RUSTSEC-2026-0367 to 0369).</li>
            <li>Library updates: Jackson 2.22.4, Gson 2.15.0, CEL 0.15.0, protobuf-java 4.37.0-RC1, commons-codec 1.23.0, commonmark 0.31.0, Caffeine 3.3.1, JaCoCo 0.8.16, ASM 9.11.1, MySQL Connector/J 26.10.0, ThreeTen-Extra 1.11.0, ntex 4.4.1, and oxc 0.156.</li>
          </ul>
        </section>
      </div>
    </div>
  </details>

  <details class="cl-release">
    <summary class="cl-release-header">
      <span class="cl-release-heading">
        <span class="cl-release-version" role="heading" aria-level="3">1.6.0</span>
      </span>
      <span class="cl-release-summary">Built-in OpenTelemetry, Python as an optional component, workspaces, a shared build cache, experimental WebAssembly, and faster startup and HTTP serving.</span>
    </summary>
    <div class="cl-release-body">
      <div class="changelog-release-links" aria-label="Release links for Elide 1.6.0">
        <a class="changelog-release-link" href="https://elide.help/docs/releases">
          <span class="changelog-release-link-label">Release notes</span>
          <code>1.6.0</code>
        </a>
        <a class="changelog-release-link changelog-release-link-github" href="https://github.com/elide-dev/elide/releases/tag/v1.6.0" target="_blank" rel="noopener noreferrer">
          <span class="changelog-github-icon"></span>
          <span class="changelog-release-link-label">GitHub</span>
          <code>v1.6.0</code>
        </a>
      </div>
      <p>Python is an optional component that <code>elide setup python</code> adds. Projects gain workspaces, a shared build cache, Maven publishing, and export to Maven and IntelliJ. WebAssembly runs as an experimental language.</p>
      <p><strong>Faster startup and serving.</strong> JavaScript hello-world starts in 1.43 ms, versus Bun’s 1.63 ms, Deno’s 6.31 ms, and Node.js’s 11.70 ms. Peak single-context serving reached 635,510 requests/sec with default settings. With 24 contexts and HTTP pipelining, the same binary peaked at 10,697,938 requests/sec and averaged 10,574,207 across three error-free runs. These are separate workloads. <a href="https://elide.help/docs/benchmarks">Results and environment</a> · <a href="https://elide.help/assets/benchmarks/http-serving-1.6.0.zip">Download the benchmark package</a></p>
      <p><strong>Shared resources, separate state.</strong> Serving contexts share a managed heap, garbage collector, eligible JIT code, and telemetry infrastructure. JavaScript globals remain separate. <a href="https://elide.help/docs/benchmarks#architecture-comparison">Architecture comparison</a></p>
      <p><strong>OpenTelemetry, built in.</strong> Use the standard JavaScript, TypeScript, or Python API; Elide supplies the SDK and export for traces, metrics, logs, and errors. Profiles are experimental. <a href="https://elide.help/docs/opentelemetry">Configure telemetry</a></p>
      <p><strong>Publish to Maven.</strong> Build and publish JARs with <code>elide publish</code>. Target your local repository, a remote repository, or Maven Central; <code>--dry-run</code> previews the upload. <a href="https://elide.help/docs/toolchain/jvm/publishing">Maven publishing</a></p>
      <p><strong>VS Code and IntelliJ IDEA.</strong> Open an <code>elide.pkl</code> project to sync dependencies and source sets. Build, run, test, debug, and view coverage through the Elide integration. <a href="https://elide.help/docs/vscode">VS Code</a> · <a href="https://elide.help/docs/intellij">IntelliJ IDEA</a></p>
      <p><strong>Report, request, file, directly from your agent or editor.</strong> Connect to <code>https://elide.help/mcp</code> to search docs, find examples, report bugs, and request features. Review and confirm each report before it becomes a public issue. <a href="https://elide.help/docs/agentic-reporting">Reporting workflow</a></p>
      <div class="cl-changes">
        <section class="cl-change" data-kind="added">
          <span class="cl-change-tag">Added</span>
          <ul class="cl-change-list">
            <li>OpenRewrite (experimental): <code>elide rewrite</code> lists, previews, and applies OpenRewrite recipes, with dependency type attribution and supported preconditions selecting files before parsing.</li>
            <li>Python is now an optional component: <code>elide setup python</code> adds it, and the install script takes <code>--with-python</code>.</li>
            <li>Workspaces: <code>workspace { members { ... } }</code> in the root <code>elide.pkl</code> builds several projects as one.</li>
            <li><code>project(&quot;core&quot;).friend()</code> lets a workspace member use a sibling's Kotlin <code>internal</code> declarations; a source set sees those of the sets it depends on.</li>
            <li><code>ELIDE_REMOTE_CACHE=&lt;url&gt;</code> shares a build cache between machines; <code>ELIDE_REMOTE_CACHE_POLICY=smart</code> transfers an entry only when that is faster than rebuilding it.</li>
            <li><code>elide build --workers=N</code> limits build concurrency.</li>
            <li>Unknown, missing, or misspelled build options fail before any task runs and name the closest match.</li>
            <li><code>ELIDE_BUILD_TELEMETRY</code> writes a Chrome trace of the build to disk.</li>
            <li>Select JVM tests with <code>--select=class:...</code>, <code>method:...</code>, or <code>package:...</code>, or by tag with <code>--include-tag</code>.</li>
            <li><code>elide test --where &quot;'api' in parents&quot;</code> filters JavaScript tests with a CEL expression over <code>name</code>, <code>parents</code>, and <code>file</code>.</li>
            <li><code>elide:cel</code> evaluates <a href="https://elide.help/docs/api-cel">CEL</a> expressions from JavaScript: compile once, evaluate many times, no side effects.</li>
            <li><code>jvm.flags</code> apply to JVM tests; <code>jvm.defs</code> apply to runs, tests, start scripts, and container images.</li>
            <li><code>kotlin.features</code> and <code>kotlin.plugins</code> configure Kotlin compiler plugins.</li>
            <li><code>elide kotlinc --abi-only</code> (experimental) emits only an ABI jar.</li>
            <li><code>dependencies.maven.substitutions</code> replaces a Maven artifact with a local jar.</li>
            <li>Jar packaging applies <code>excludes</code>, keeps requested classifiers, and merges <code>META-INF/services</code>.</li>
            <li>A <code>Jvm.JvmApplication</code> artifact packages a runnable JVM application with start scripts and archives.</li>
            <li>Maven publishing: <code>elide publish</code> installs a library into the local Maven repository, or publishes it to a named repository or Maven Central (<code>--to</code>) with checksums and <code>gpg</code> signatures; <code>--dry-run</code> lists what it would send.</li>
            <li>Java annotation processors declared under <code>processors</code> run during compilation.</li>
            <li><code>elide run --coverage</code> collects coverage from a run: JaCoCo for Java and Kotlin, LCOV for JavaScript and TypeScript.</li>
            <li><code>elide run</code> and <code>elide test</code> exit with the program's own exit code.</li>
            <li><code>--allow-env[=NAMES]</code> lets a manifest read environment variables outside the default allowlist.</li>
            <li><code>--max-mem=512m</code> limits the heap; one-shot runs default to 4 GB.</li>
            <li><code>--contexts=N</code> or <code>--contexts=auto</code> serves from several application contexts.</li>
            <li><code>elide project export</code> prints the manifest as JSON, a Maven POM, or an IntelliJ project; it replaces <code>elide manifest</code>.</li>
            <li>WebAssembly (experimental): <code>elide run app.wasm</code> runs a WASI command, JavaScript and TypeScript load WASM libraries with the <code>WebAssembly</code> API or <code>import</code>, and <code>elide native-image</code> compiles a JVM application to WebAssembly.</li>
            <li>The docs MCP server at <code>https://elide.help/mcp</code> searches the docs, compares runtimes, and files bug, performance, expectation, and feature reports once you confirm.</li>
            <li><code>elide agent perf</code> times a command against another runtime or an installed Elide version, offline.</li>
          </ul>
          <p><a href="https://elide.help/docs/elide-pkl-reference#workspaces">Workspaces</a> · <a href="https://elide.help/docs/wasm">WebAssembly and WASI</a> · <a href="https://elide.help/docs/toolchain/source-sets">Source sets</a></p>
        </section>
        <section class="cl-change" data-kind="changed">
          <span class="cl-change-tag">Changed</span>
          <ul class="cl-change-list">
            <li>Serving and <code>fetch</code> use the native transport by default on Linux and macOS; <code>--transport=nio</code> selects the portable one.</li>
            <li>A program starts only the languages it uses; <code>--interop</code> lets JavaScript, TypeScript, and Python call each other.</li>
            <li>Source sets follow convention: <code>src/&lt;set&gt;/&lt;language&gt;</code>, <code>src/&lt;set&gt;</code>, then a flat <code>src</code> or <code>test</code>.</li>
            <li><code>elide test</code> stops discovery at a nested project; name its path to run it.</li>
            <li>A <code>--release</code> build no longer counts as up to date after a debug build.</li>
            <li>Plain <code>http://</code> Maven repositories are refused except on loopback; <code>--allow-http-repositories</code> allows them.</li>
            <li><code>--timeout</code> kills the whole process tree, then exits <code>124</code>; <code>--timeout 0</code> disables it.</li>
            <li><code>NODE_TLS_REJECT_UNAUTHORIZED=0</code> prints Node's warning once.</li>
            <li>jvmstat is off by default; <code>--vmstat</code> makes the process visible to <code>jps</code>, <code>jstat</code>, and <code>jcmd</code>.</li>
            <li>Development, MCP, and CDP servers accept only local <code>Host</code> and <code>Origin</code> values; <code>elide mcp</code> reads <code>ELIDE_MCP_TOKEN</code>.</li>
            <li>A pinned version that is not installed prompts before downloading; <code>ELIDE_AUTO_INSTALL=1</code> answers yes.</li>
            <li>Java compiles with <code>--release</code>, targeting <code>jvm.target</code> (default Java 21).</li>
            <li>A <code>JavadocJar</code> whose sources include Kotlin is generated by Dokka; <code>generator = "javadoc"</code> keeps <code>javadoc</code>.</li>
            <li>Release channels are <code>release</code> and <code>nightly</code>, and the install scripts default to <code>release</code>; <code>preview</code> is gone.</li>
            <li>Linux builds link glibc dynamically and need glibc 2.34 or later; 1.3 builds were static, and musl distributions such as Alpine are no longer supported.</li>
            <li>Within a <code>MAJOR.MINOR</code> line, patch releases only add manifest schema properties; a manifest that uses a removed property fails and names the version to pin.</li>
            <li>JVM coverage reports go under <code>.dev/reports/coverage/jvm/</code>.</li>
            <li>A top-level <code>coverage</code> block in <code>elide.pkl</code> replaces <code>testing.coverage</code>.</li>
            <li><code>elide agent bug --json</code> prints an <code>elide.report/1</code> skeleton; <code>--kind</code> selects <code>bug</code>, <code>perf</code>, <code>expectation</code>, or <code>feature</code>.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="fixed">
          <span class="cl-change-tag">Fixed</span>
          <ul class="cl-change-list">
            <li>Memory and CPU limits apply in containers with a private cgroup namespace (the Docker and Podman default) and on cgroup v1 and hybrid hosts.</li>
            <li>Startup no longer crashes on linux-arm64; Windows startup and the directory watcher work again.</li>
            <li>Python: <code>bz2</code>, <code>lzma</code>, and <code>multiprocessing</code> spawn pools work.</li>
            <li>Python: thread switching, <code>gc.collect()</code>, warnings, and <code>ProcessPoolExecutor</code> shutdown match CPython.</li>
            <li>Python: <code>assert</code> runs (<code>__debug__</code> is <code>True</code> unless <code>-O</code>), <code>sys.flags</code> matches CPython, and <code>-E</code> and <code>-I</code> ignore <code>VIRTUAL_ENV</code>.</li>
            <li>Python: tracebacks from a <code>.py</code> file start at that file; starting a thread without <code>--allow-threads</code> raises <code>RuntimeError</code> naming the flag.</li>
            <li><code>fetch</code> retries an idempotent request on a closed keep-alive connection; <code>https</code> applies <code>ca</code>.</li>
            <li><code>fetch</code> over HTTP/2 runs at full speed on high-latency links, and a response dropped unread releases its connection.</li>
            <li>Node: <code>MessagePort</code>, <code>BroadcastChannel</code>, <code>dgram</code>, <code>net</code>, <code>dns</code>, <code>fs</code>, streams, <code>vm</code>, <code>AsyncLocalStorage</code>, signals, and child-process IPC match Node.</li>
            <li><code>console.log</code> prints objects, arrays, and maps as Node does.</li>
            <li><code>AsyncContext</code> values reach timer, <code>setImmediate</code>, <code>process.nextTick</code>, and <code>queueMicrotask</code> callbacks; <code>Intl.Segmenter</code> splits Chinese and Japanese words.</li>
            <li>TypeScript keeps its source line numbers in stack traces, test failures, coverage, and debugger breakpoints.</li>
            <li>The DAP debugger no longer pauses on entry and prints <code>Debugger listening on …</code>.</li>
            <li>HTTP serving answers <code>413</code> for oversized uploads, <code>400</code> for malformed or conflicting headers, and <code>408</code> for a stalled request body; <code>elide dev</code> answers <code>405</code> to methods other than <code>GET</code> and <code>HEAD</code>.</li>
            <li>Static files with percent-encoded paths resolve.</li>
            <li>The development server reloads only when files change.</li>
            <li>REPL: Ctrl+C no longer resets an idle session, and Ctrl+D exits a runaway evaluation.</li>
            <li><code>elide init</code> and archive extraction refuse entries and links that escape the target directory, and extraction drops setuid bits.</li>
            <li>Crash reports refuse a planted crash directory and honor <code>ELIDE_SYS_TMP</code>.</li>
            <li><code>--allow-run=name</code> no longer allows a path-qualified command of that name.</li>
            <li><code>elide install</code> no longer hangs on a TLS server that requires a client certificate.</li>
            <li>javac applies <code>-encoding</code>.</li>
            <li>Kotlin: <code>elide run file.kt</code> works with compiler plugins; changing <code>kotlin.features</code> recompiles.</li>
            <li>Kotlin: single files can use the <code>elide-api</code> annotations, a snippet without <code>main</code> fails with one message, and <code>.kts</code> files in a source set are skipped with a warning.</li>
            <li><code>elide kotlinc -Xplugin=</code> runs the all-open, no-arg, sam-with-receiver, assignment, and Lombok plugins, from Maven and Bazel too; other plugin JARs fail with a compiler error instead of a crash.</li>
            <li><code>elide kotlinc --plugins serialization</code>, <code>atomicfu</code>, or <code>metro</code> adds the plugin's runtime; Kotlin projects get the atomicfu runtime, and incremental compiles see Java sources.</li>
            <li><code>elide-api</code> with version <code>latest</code> resolves, <code>jvm.features.testing = false</code> drops the bundled JUnit, and <code>elide classpath</code> reports a failed resolution instead of crashing.</li>
            <li><code>--insights</code> applies to single-file Java and Kotlin runs, and a broad filter no longer stops the JVM.</li>
            <li>The archives ship <code>lib/jspawnhelper</code> executable, so Elide as <code>JAVA_HOME</code> runs forked JVMs such as Surefire's.</li>
            <li><code>elide mvn</code> verifies the native Maven download before running it.</li>
            <li><code>elide build --workers 2</code> is refused, and the error names the <code>--workers=2</code> spelling.</li>
            <li>A task record that cannot be saved no longer makes every task rebuild.</li>
            <li>Tests: a suite that skips itself reports as skipped; every <code>--exec</code> file is included in the JaCoCo report.</li>
            <li>MCP <code>build/cancel</code> reports <code>cancelled=true</code> only when it stopped a build.</li>
            <li><code>--heap-dump-on-oom</code> exits after writing the dump.</li>
            <li><code>elide serve</code> keeps the newest request visible.</li>
            <li>Subcommand help shows its footer.</li>
            <li><code>elide run</code> and <code>elide init</code> print each error once, <code>elide test</code> no longer prints <code>Build failed</code> when tests fail, and <code>elide -p DIR adopt</code> adopts <code>DIR</code>.</li>
            <li><code>LANG=fr</code> and other bare language tags select that language, and <code>--locale</code> applies to <code>--help</code>; <code>elide lsp</code> reports its version to the editor.</li>
            <li>Nightly versions pinned by date no longer re-download.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="chore">
          <span class="cl-change-tag">Maintenance</span>
          <ul class="cl-change-list">
            <li>Kotlin 2.5.0-Beta1; manifests accept Kotlin language and API level <code>2.5</code>.</li>
            <li>JDK 25.0.4.</li>
            <li>Python 3.13.</li>
          </ul>
        </section>
      </div>
      <h4 id="story-openrewrite">OpenRewrite (experimental)</h4>
      <p><code>elide rewrite</code> lists, previews, and applies OpenRewrite recipes. Add recipe modules to <code>dependencies.maven.devPackages</code>; Elide supplies dependency type information without a build plugin.</p>
      <p>Supported preconditions use the reference index to select candidate files before parsing. Other recipes scan the full source set. <code>--no-prefilter</code> skips compilation and parses every Java source.</p>
      <p>Use the index directly to resolve classes, inspect members, follow references, and find Java or Kotlin usages with <code>elide index used-by</code>.</p>
      <p>Experimental in 1.6.0, with compatibility hardening planned for 1.6.1. Dependency annotation values are not yet supported. Review the dry-run diff before applying changes.</p>
      <pre><code class="language-bash">elide rewrite --list
elide rewrite org.openrewrite.java.RemoveUnusedImports --dry-run
elide rewrite org.openrewrite.java.RemoveUnusedImports</code></pre>
      <p><a href="https://elide.help/docs/toolchain/jvm/rewrite">OpenRewrite workflow</a> · <a href="https://elide.help/docs/toolchain/jvm/code-index">Dependency code index</a></p>
    </div>
  </details>

  <details class="cl-release">
    <summary class="cl-release-header">
      <span class="cl-release-heading">
        <span class="cl-release-version" role="heading" aria-level="3">1.5.4</span>
      </span>
      <span class="cl-release-summary">Experimental native transport v2, faster HTTP serving, and clearer profiling and tooling diagnostics.</span>
    </summary>
    <div class="cl-release-body">
      <div class="changelog-release-links" aria-label="Release links for Elide 1.5.4">
        <a class="changelog-release-link changelog-release-link-github" href="https://github.com/elide-dev/elide/releases/tag/1.5.4%2B20260921" target="_blank" rel="noopener noreferrer">
          <span class="changelog-github-icon"></span>
          <span class="changelog-release-link-label">GitHub</span>
          <code>1.5.4+20260921</code>
        </a>
      </div>
      <div class="cl-changes">
        <section class="cl-change" data-kind="added">
          <span class="cl-change-tag">Added</span>
          <ul class="cl-change-list">
            <li>Opt into the experimental v2 transport with <code>--transport=v2</code> or <code>ELIDE_TRANSPORT_V2=1</code>. An explicit <code>--transport</code> flag takes precedence; <code>auto</code> keeps the existing default.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="changed">
          <span class="cl-change-tag">Changed</span>
          <ul class="cl-change-list">
            <li>Serve static files faster, with cached-file revalidation.</li>
            <li>Reduce HTTP request overhead with native HTTP/1 parsing and response encoding for transport v2, cached URL parsing and header names, and fewer per-response allocations.</li>
            <li>Reduce JavaScript allocation and execution overhead in URL, header, buffer, and filesystem operations.</li>
            <li>Start faster and download a smaller distribution.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="fixed">
          <span class="cl-change-tag">Fixed</span>
          <ul class="cl-change-list">
            <li>Collect CLI profiler results after asynchronous work and exit handlers finish, including Python project entry points.</li>
            <li>Print profiler results when a long-running program is stopped with Ctrl+C, with bounded shutdown reporting.</li>
            <li>Show expected build-tool failures as user-friendly errors instead of stack traces or crash reports, and render Java and Kotlin compiler diagnostics consistently in direct tool calls and project builds.</li>
          </ul>
        </section>
      </div>
    </div>
  </details>

  <details class="cl-release">
    <summary class="cl-release-header">
      <span class="cl-release-heading">
        <span class="cl-release-version" role="heading" aria-level="3">1.5.3</span>
      </span>
      <span class="cl-release-summary">Faster startup and HTTP serving, test debugging, resource limits, and fixes for bundled JVM tools.</span>
    </summary>
    <div class="cl-release-body">
      <div class="changelog-release-links" aria-label="Release links for Elide 1.5.3">
        <a class="changelog-release-link changelog-release-link-github" href="https://github.com/elide-dev/elide/releases/tag/1.5.3%2B20260917" target="_blank" rel="noopener noreferrer">
          <span class="changelog-github-icon"></span>
          <span class="changelog-release-link-label">GitHub</span>
          <code>1.5.3+20260917</code>
        </a>
      </div>
      <div class="cl-changes">
        <section class="cl-change" data-kind="changed">
          <span class="cl-change-tag">Changed</span>
          <ul class="cl-change-list">
            <li>Start JavaScript programs faster: a Linux release benchmark cut <code>elide run hello.js</code> from 31 ms to 7.7 ms.</li>
            <li>Serve more HTTP requests: the Linux echo benchmark improved 4.5×, from 25K to 114K requests/sec at 256 connections. Static and development servers also reuse HTTP/1.1 connections for faster repeat requests.</li>
            <li>Download smaller distributions while keeping Java and Kotlin compilers, formatters, and other JVM tools included by default.</li>
            <li>Run JavaScript tests with less overhead and lower memory use after tests finish. Programs using buffers, URLs, events, timers, and console output also allocate less memory.</li>
            <li>Keep native HTTP and WebSocket services within a bounded number of background threads under load.</li>
          </ul>
          <p><a href="https://elide.help/docs/dev-server">Development Server</a></p>
        </section>
        <section class="cl-change" data-kind="added">
          <span class="cl-change-tag">Added</span>
          <ul class="cl-change-list">
            <li>Attach a debugger to tests with <code>elide test --debugger</code>: use Chrome DevTools for JavaScript/TypeScript tests or a JVM debugger for Java/Kotlin tests. Select a JVM port with <code>--debugger=5005</code>.</li>
            <li>TAP test reports include test-start events and associate output with the test that produced it, helping editors show progress and diagnostics.</li>
            <li>Limit JavaScript/TypeScript workers and open <code>node:fs</code> handles with <code>--limit=workers=COUNT</code> and <code>--limit=fds=COUNT</code> on scripts and <code>elide run</code>. Limits include descendant workers; <code>--timeout</code> requests cleanup of the script and its workers.</li>
            <li>Select trusted execution with <code>--sandbox=trusted</code> and explicitly control native access with <code>--allow-native</code> or <code>--no-native</code>. Bare <code>--sandbox</code> keeps its filesystem-only behavior.</li>
            <li>Pin a nightly manifest schema at <code>pkl.elide.dev/&lt;version&gt;-&lt;stamp&gt;/project.pkl</code>; Elide rejects stamps that do not match its embedded build.</li>
          </ul>
          <p><a href="https://elide.help/docs/debugging">Debugging tests</a> · <a href="https://elide.help/docs/sandbox">Permissions and resource limits</a> · <a href="https://elide.help/docs/elide-pkl-reference">Manifest reference</a></p>
        </section>
        <section class="cl-change" data-kind="fixed">
          <span class="cl-change-tag">Fixed</span>
          <ul class="cl-change-list">
            <li>Bundled JVM tools work through the standard macOS installation: <code>elide javac -- -help</code>, Java compilation, and other JVM tool commands no longer incorrectly report that <code>jvmtools</code> is missing when <code>elide</code> is launched through an installation symlink. No separate toolchain installation is needed.</li>
            <li>Keep filesystem, network, and subprocess permissions scoped to each workload, including its workers and background file operations, so one workload’s settings do not change another’s access.</li>
            <li>Cancel an HTTP request without a late cancellation interrupting an unrelated request.</li>
            <li>JVM debugging now listens on <code>127.0.0.1</code> by default. For remote attachment, set an explicit address such as <code>--debugger=0.0.0.0:5005</code>. Invalid debugger options are rejected instead of silently running without a debugger.</li>
            <li>Keep update notices out of redirected stderr and CI logs, and report timeout errors in the selected language.</li>
            <li>Fix <code>elide classpath -q</code>. Tool wrappers reject misplaced <code>--version</code>; pass tool flags after <code>--</code>, as in <code>elide jar -- --version</code>. Formatter help explains how to check without rewriting files.</li>
            <li>Copy code snippets throughout the docs with a dedicated copy button.</li>
          </ul>
          <p><a href="https://elide.help/docs/cli-references">CLI reference</a></p>
        </section>
      </div>
    </div>
  </details>

  <details class="cl-release">
    <summary class="cl-release-header">
      <span class="cl-release-heading">
        <span class="cl-release-version" role="heading" aria-level="3">1.5.2</span>
      </span>
      <span class="cl-release-summary">Native HTTP transport, flight recordings and heap dumps, typed build flags, <code>elide adopt</code>, a TAP reporter, and broad CLI and Node fixes.</span>
    </summary>
    <div class="cl-release-body">
      <div class="changelog-release-links" aria-label="Release links for Elide 1.5.2">
        <a class="changelog-release-link changelog-release-link-github" href="https://github.com/elide-dev/elide/releases/tag/1.5.2%2B20260908" target="_blank" rel="noopener noreferrer">
          <span class="changelog-github-icon"></span>
          <span class="changelog-release-link-label">GitHub</span>
          <code>1.5.2+20260908</code>
        </a>
      </div>
      <div class="cl-changes">
        <section class="cl-change" data-kind="added">
          <span class="cl-change-tag">Added</span>
          <ul class="cl-change-list">
            <li>New <code>elide adopt</code> command adopts Elide in an existing project through Claude or Codex; every prompt can be answered up front for non-interactive use.</li>
            <li>Typed build flags: <code>--flag=NAME[=VALUE]</code> or <code>-fNAME</code> on every project-aware command, read from <code>build.flags</code> in the manifest. See <a href="https://elide.help/docs/toolchain/build-flags">Build Flags</a>.</li>
            <li>An ES module that exports a <code>fetch</code> handler runs as a server under <code>elide run</code>, <code>elide serve</code>, and <code>elide dev</code>; interactive <code>serve</code> and <code>dev</code> show the serving TUI for scripts.</li>
            <li>Native builds route <code>fetch</code> and <code>Elide.serve</code> through a native HTTP transport: HTTP/1.1 and HTTP/2, streaming bodies, cancellation, graceful shutdown, and HTTP proxy support. <code>elide info</code> reports the active backend.</li>
            <li><code>elide test --reporter tap</code> emits one TAP 13 stream for JavaScript and JVM tests; <code>--reporter-outfile</code> writes <code>.tap</code> files.</li>
            <li>Capture JFR recordings and heap dumps with <code>--jfr</code>, <code>--jfr-settings</code>, <code>--heap-dump</code>, and <code>--heap-dump-on-oom</code>, or familiar <code>-XX:</code> options; see <code>elide help instruments</code>.</li>
            <li>Inspect running native processes with jvmstat and the JDK's <code>jcmd</code> on Linux and macOS: start and dump recordings, capture heaps, and print thread stacks.</li>
            <li>Profile JIT-compiled guest code with <code>--jitdump</code> and Linux <code>perf</code>.</li>
            <li>Elide-specific JFR events record runtime boot, guest program start and exit, and HTTP request lifecycle.</li>
            <li>Debugger listeners bind to configurable hosts and ports.</li>
            <li>The project manifest Pkl schema is published per Elide release at <code>pkl.elide.dev/&lt;version&gt;/</code>, for editor tooling and <code>amends</code> clauses; a manifest may pin one of those versions, and a pin newer than the Elide evaluating it is read with that Elide's schema.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="fixed">
          <span class="cl-change-tag">Fixed</span>
          <ul class="cl-change-list">
            <li><code>elide run</code> sent a JVM program's stdout to stderr. Guest output is now written to Elide's own streams byte for byte, redirected output is free of ANSI, and <code>--no-color</code> and <code>--quiet</code> apply to build output.</li>
            <li><code>elide run --debugger</code> no longer starts an unrequested MCP endpoint; the inspector identifies itself as Elide, suspension messages are clearer, and an errant flag warning is gone.</li>
            <li><code>--version</code> and <code>--help-all</code> work on commands with required arguments, and <code>--help-all</code> describes the selected command rather than the root.</li>
            <li><code>--debugger</code> and <code>--profiler</code> are global like the rest of the diagnostics flags; <code>--quiet</code> no longer suppresses <code>manifest</code>, <code>project info</code>, or <code>project advice</code> output; stale flags were removed from help.</li>
            <li><code>elide test</code> rejects unknown <code>--reporter</code> values, parses <code>-t=pattern</code>, skips <code>vendor/</code>, resolves the project from a named test path, and skips JVM tests when paths match only JavaScript tests.</li>
            <li><code>elide init</code> prints a diagnostic on every non-interactive failure path.</li>
            <li><code>elide javaformat --list-diffs</code> no longer rewrites files in place, and <code>elide mvn</code> locates Maven home.</li>
            <li>Node: <code>node:test</code> files run outside <code>elide test</code> fail with an error instead of being skipped silently; <code>scrypt</code> accepts derived-key lengths below 16; <code>performance.measure</code> uses a named start mark; queuing strategy <code>size</code> is read correctly; <code>spawnSync</code> applies <code>inherit</code> and <code>ignore</code> stdio; <code>dns.lookup</code> with <code>all</code>; unknown <code>node:</code> imports throw; <code>performance.nodeTiming</code> and timeout messages match Node.</li>
            <li>Ticks and microtasks now run after each timer callback, matching Node's ordering; stream destroy callbacks run at the correct time.</li>
            <li>Context scheduling handles creation failures, shutdown races, and full callback queues.</li>
            <li><code>--profiler=memtracing</code> no longer aborts at startup.</li>
            <li>Maven module dependencies are added to the <code>elide native-image</code> classpath; a build fails when it references a missing artifact.</li>
            <li>The apt repository's signing key verifies on current Ubuntu releases.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="changed">
          <span class="cl-change-tag">Changed</span>
          <ul class="cl-change-list">
            <li>Native builds on Linux and macOS arm64 allocate through one mimalloc core across Rust, C, and runtime unmanaged memory.</li>
            <li>The JVM toolchain is in a shared library beside the binary, loaded on demand; the main executable is smaller.</li>
            <li>Terminal rendering moved to a single Rust renderer, replacing the vendored JVM terminal libraries.</li>
            <li>The <code>elide help</code> corpus is a separate file at <code>doc/elide-docs.bin</code> beside the binary; <code>ELIDE_DOCS</code> overrides its location.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="chore">
          <span class="cl-change-tag">Maintenance</span>
          <ul class="cl-change-list">
            <li>Upgraded the Rust toolchain to <code>1.100.x</code> and LLVM to <code>23.x</code>.</li>
            <li>New guides: <a href="https://elide.help/docs/instruments">Monitoring and Profiling</a>, <a href="https://elide.help/docs/toolchain/build-flags">Build Flags</a>, VS Code and IntelliJ plugins, native Maven, architecture tours, and a generated embedded-versions page.</li>
          </ul>
        </section>
      </div>
    </div>
  </details>

  <details class="cl-release">
    <summary class="cl-release-header">
      <span class="cl-release-heading">
        <span class="cl-release-version" role="heading" aria-level="3">1.5.1</span>
      </span>
      <span class="cl-release-summary">Small bugfix release following 1.5.0: REPL multiline fixes and Node TLS environment variables for <code>fetch</code>.</span>
    </summary>
    <div class="cl-release-body">
      <div class="cl-changes">
        <section class="cl-change" data-kind="added">
          <span class="cl-change-tag">Added</span>
          <ul class="cl-change-list">
            <li><code>fetch</code> reads Node's TLS environment variables: <code>NODE_TLS_REJECT_UNAUTHORIZED</code>, <code>NODE_USE_SYSTEM_CA</code>, and <code>NODE_EXTRA_CA_CERTS</code>.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="fixed">
          <span class="cl-change-tag">Fixed</span>
          <ul class="cl-change-list">
            <li>The REPL handles newlines correctly and no longer renders multiline prompts incorrectly.</li>
          </ul>
        </section>
      </div>
    </div>
  </details>

  <details class="cl-release">
    <summary class="cl-release-header">
      <span class="cl-release-heading">
        <span class="cl-release-version" role="heading" aria-level="3">1.5.0</span>
      </span>
      <span class="cl-release-summary">Updates the Python and JVM toolchains and expands Node compatibility across core runtime APIs.</span>
    </summary>
    <div class="cl-release-body">
      <div class="changelog-release-links" aria-label="Release links for Elide 1.5.0">
        <a class="changelog-release-link" href="https://elide.help/docs/releases">
          <span class="changelog-release-link-label">Release notes</span>
          <code>1.5.0</code>
        </a>
        <a class="changelog-release-link changelog-release-link-github" href="https://github.com/elide-dev/elide/releases/tag/1.5.0%2B20260902" target="_blank" rel="noopener noreferrer">
          <span class="changelog-github-icon"></span>
          <span class="changelog-release-link-label">GitHub</span>
          <code>1.5.0+20260902</code>
        </a>
      </div>
      <div class="cl-changes">
        <section class="cl-change" data-kind="changed">
          <span class="cl-change-tag">Changed</span>
          <ul class="cl-change-list">
            <li>The embedded Python runtime and bundled standard library target Python <code>3.13</code>.</li>
            <li>The bundled Kotlin compiler is updated to <code>2.4.10</code>; the Java toolchain targets JDK 25.</li>
            <li><code>elide:crypto</code>, <code>elide:fs</code>, <code>elide:net</code>, and <code>elide:process</code> now match their <code>node:*</code> modules. Compression remains available through <code>node:zlib</code> and the Compression Streams API; there is no <code>elide:compression</code> module.</li>
            <li>Buffer, timer handles, process and OS data, performance APIs, async context and abort behavior, TLS, and other Node compatibility were expanded or corrected.</li>
            <li><code>process.env</code> can be replaced, and <code>process.loadEnvFile([path])</code> explicitly loads dotenv files.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="added">
          <span class="cl-change-tag">Added</span>
          <ul class="cl-change-list">
            <li><code>node:zlib</code> adds Zstandard support, stream constructors, <code>crc32</code>, and <code>codes</code>.</li>
            <li><code>node:util</code> adds formatting, <code>callbackify</code>, <code>inherits</code>, deep equality, deprecation and debug helpers, system-error helpers, ANSI stripping and styling, and dotenv parsing.</li>
            <li><code>PerformanceObserver.supportedEntryTypes</code> includes <code>function</code>, and the module loader exposes <code>node:http</code> and <code>node:tls</code>.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="chore">
          <span class="cl-change-tag">Maintenance</span>
          <ul class="cl-change-list">
            <li>The CLI, project, installation, and language guides were consolidated and verified against the 1.5 binary.</li>
            <li>Server guidance now reflects the static and development servers' observed <code>3000</code> default.</li>
          </ul>
        </section>
      </div>
    </div>
  </details>

  <details class="cl-release">
    <summary class="cl-release-header">
      <span class="cl-release-heading">
        <span class="cl-release-version" role="heading" aria-level="3">1.4.7</span>
      </span>
      <span class="cl-release-summary">Installs native Maven images on demand, adds Spring-specialized builds, and fixes the nightly upgrade prompt.</span>
    </summary>
    <div class="cl-release-body">
      <div class="changelog-release-links" aria-label="Release links for Elide 1.4.7">
        <a class="changelog-release-link" href="https://elide.help/docs/releases">
          <span class="changelog-release-link-label">Release notes</span>
          <code>1.4.7</code>
        </a>
        <a class="changelog-release-link changelog-release-link-github" href="https://github.com/elide-dev/elide/releases/tag/1.4.7%2B20260901" target="_blank" rel="noopener noreferrer">
          <span class="changelog-github-icon"></span>
          <span class="changelog-release-link-label">GitHub</span>
          <code>1.4.7+20260901</code>
        </a>
      </div>
      <div class="cl-changes">
        <section class="cl-change" data-kind="added">
          <span class="cl-change-tag">Added</span>
          <ul class="cl-change-list">
            <li><code>elide mvn --flavor spring@&lt;version&gt;</code> selects a native Maven image specialized for a Spring Boot line. Without the flag, the project's POM is read for its Boot version and the matching image is chosen, or the generic one if none matches.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="fixed">
          <span class="cl-change-tag">Fixed</span>
          <ul class="cl-change-list">
            <li><code>elide upgrade --channel=nightly</code> no longer offers a build to itself as <code>v1.4.6 -&gt; v1.4.6</code>. Both sides of the message include the datestamp and commit that identify a nightly, so the running build and the candidate are distinguishable.</li>
            <li><code>elide javaformat</code> and <code>elide ktfmt</code> walk directory arguments.</li>
            <li><code>elide init</code> no longer requires a TTY for the documented non-interactive run.</li>
            <li><code>elide serve --host</code> is applied.</li>
            <li><code>elide install --with</code> rejects unknown classifiers.</li>
            <li><code>elide test</code> runs sequentially by default on both engines.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="changed">
          <span class="cl-change-tag">Changed</span>
          <ul class="cl-change-list">
            <li>The distribution no longer bundles native Maven images. <code>elide mvn</code> installs the image it needs on first use.</li>
          </ul>
        </section>
      </div>
    </div>
  </details>

  <details class="cl-release">
    <summary class="cl-release-header">
      <span class="cl-release-heading">
        <span class="cl-release-version" role="heading" aria-level="3">1.4.6</span>
      </span>
      <span class="cl-release-summary">Parallelizes <code>elide test</code>, narrows <code>elide install</code> to Maven by default, and reorganizes the CLI help.</span>
    </summary>
    <div class="cl-release-body">
      <div class="changelog-release-links" aria-label="Release links for Elide 1.4.6">
        <a class="changelog-release-link" href="https://elide.help/docs/releases">
          <span class="changelog-release-link-label">Release notes</span>
          <code>1.4.6</code>
        </a>
        <a class="changelog-release-link changelog-release-link-github" href="https://github.com/elide-dev/elide/releases/tag/1.4.6%2B20260830" target="_blank" rel="noopener noreferrer">
          <span class="changelog-github-icon"></span>
          <span class="changelog-release-link-label">GitHub</span>
          <code>1.4.6+20260830</code>
        </a>
      </div>
      <div class="cl-changes">
        <section class="cl-change" data-kind="added">
          <span class="cl-change-tag">Added</span>
          <ul class="cl-change-list">
            <li><code>elide --help</code> now groups commands under four headings and hides ten rarely used commands; <code>--help-all</code> prints everything.</li>
            <li>A <code>--profiler=memtracing</code> mode that uses the runtime memory tracer.</li>
            <li>Build tools record their argument vectors as <code>&lt;tool&gt;.args</code> beside primary outputs &mdash; <code>javac</code> and <code>kotlinc</code> as well as <code>native-image</code> &mdash; and the recorded argfiles are inputs to the build cache.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="fixed">
          <span class="cl-change-tag">Fixed</span>
          <ul class="cl-change-list">
            <li>All manifest evaluations now share one execution layer, fixing "invalid sharing of AST nodes" errors on a second manifest evaluation.</li>
            <li>Precompiler diagnostics are scoped per operation, so concurrent precompiles no longer report each other's errors.</li>
            <li>Maven POM profiles activated by <code>&lt;activation&gt;&lt;condition&gt;</code> expressions now evaluate correctly.</li>
            <li>Mutable multipath container operations are implemented rather than stubbed.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="changed">
          <span class="cl-change-tag">Changed</span>
          <ul class="cl-change-list">
            <li><code>elide test</code> runs in parallel on both engines: <code>--concurrency</code> defaults to one worker per CPU (test files for JavaScript, test classes for the JVM), <code>--concurrency=1</code> forces a sequential run, and <code>--concurrency=0</code> is rejected at parse time. Discovery overhead is reduced, and JVM tests are no longer recompiled on every invocation.</li>
            <li>Coverage is now opt-in on both test engines: collection happens only when <code>--coverage</code> is passed or the manifest enables it, and the manifest default is now off.</li>
            <li><code>elide install</code> installs Maven dependencies and nothing else by default; a neighboring <code>package.json</code>, <code>pyproject.toml</code>, or <code>requirements.txt</code> produces a one-line note on stderr, and <code>--ecosystems=&lt;names&gt;</code> installs other ecosystems. <code>uv</code> is no longer bundled.</li>
            <li>The default <code>elide test --coverage</code> report is a rollup summary; per-file rows appear with <code>--verbose</code>.</li>
            <li>The download is roughly 30 MiB smaller.</li>
          </ul>
        </section>
      </div>
    </div>
  </details>

  <details class="cl-release">
    <summary class="cl-release-header">
      <span class="cl-release-heading">
        <span class="cl-release-version" role="heading" aria-level="3">1.4.5</span>
      </span>
      <span class="cl-release-summary">Retires the closed-source subsystems for the Apache-2.0 open-source release, adds CLI commands for AI coding agents, and fixes incorrect results across test, format, run, install, and classpath.</span>
    </summary>
    <div class="cl-release-body">
      <div class="changelog-release-links" aria-label="Release links for Elide 1.4.5">
        <a class="changelog-release-link" href="https://elide.help/docs/releases">
          <span class="changelog-release-link-label">Release notes</span>
          <code>1.4.5</code>
        </a>
        <a class="changelog-release-link changelog-release-link-github" href="https://github.com/elide-dev/elide/releases/tag/1.4.5%2B20260827" target="_blank" rel="noopener noreferrer">
          <span class="changelog-github-icon"></span>
          <span class="changelog-release-link-label">GitHub</span>
          <code>1.4.5+20260827</code>
        </a>
      </div>
      <div class="cl-changes">
        <section class="cl-change" data-kind="added">
          <span class="cl-change-tag">Added</span>
          <ul class="cl-change-list">
            <li><code>elide agent</code>, commands for AI coding agents: <code>agent help</code> prints documentation as Markdown on stdout, <code>agent diagnostics</code> reports status (with <code>--json</code>), and <code>agent bug</code> assembles a bug report. <code>elide help &lt;topic&gt; --format=markdown</code> works everywhere, and <code>elide help</code> no longer panics for non-interactive callers.</li>
            <li>Elide detects when an AI coding agent is running it and switches to plain output &mdash; no ANSI sequences, no frames &mdash; in both the parsing and rendering layers.</li>
            <li><code>elide install</code> writes resolved classpath files to <code>.dev/dependencies/m2/{compile,runtime,test,processors}.classpath</code>, in the same format <code>elide classpath &lt;usage&gt;</code> prints, so external tools can read a classpath without invoking Elide.</li>
            <li>Distributions include the Apache-2.0 <code>LICENSE</code> and <code>NOTICE</code>.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="fixed">
          <span class="cl-change-tag">Fixed</span>
          <ul class="cl-change-list">
            <li><code>elide format</code> on Java silently did nothing in write mode &mdash; formatted output was discarded instead of written back &mdash; and check/dry-run modes mis-reported results for both Java and Kotlin.</li>
            <li><code>elide test &lt;path&gt;</code> treats paths as a real filter: zero matches now fails and names the paths, and the JVM engine no longer runs the whole suite unfiltered while reporting success. A package-like bare token maps to a JUnit package selector, and an existing path always takes precedence, resolved against the project root.</li>
            <li><code>-t</code>/<code>--test-name-pattern</code> performs the documented unanchored search on the JVM engine, and an empty filtered run exits non-zero.</li>
            <li><code>elide run &lt;name&gt;</code> follows a total, documented resolution order &mdash; source file, then <code>elide.pkl</code> scripts, then <code>package.json</code>/<code>pyproject.toml</code> scripts, then <code>node_modules/.bin/&lt;name&gt;</code> &mdash; and produces a real diagnostic when nothing matches.</li>
            <li><code>elide build &lt;target&gt;</code> accepts the documented target groups, and <code>elide install --with</code> is applied.</li>
            <li><code>elide classpath</code> errors on an unparseable usage spec instead of silently returning the main compile classpath, and Maven exclusions are applied.</li>
            <li><code>--timeout</code> starts before fast-path dispatch, so it now applies to <code>repl</code>, <code>serve</code>, <code>dev</code>, <code>help</code>, <code>agent</code>, and <code>init</code>.</li>
            <li><code>elide serve</code> defaults to the documented port 8080, <code>kotlinc</code> accepts <code>--max-errors</code>, and a mistyped subcommand produces a clear error.</li>
            <li><code>--no-color</code>, <code>NO_COLOR</code>, and <code>TERM=dumb</code> apply to the help masthead and progress output; a shared terminal check lets <code>elide init &lt; /dev/null</code> exit cleanly; and the REPL reads piped stdin.</li>
            <li>Usage errors have their own exit code, distinct from guest failures, and error color is used only on a real terminal.</li>
            <li><code>process.exit</code> codes are preserved on the inline-snippet path, and top-level <code>-c</code> snippets match CPython <code>argv</code> semantics.</li>
            <li>Retired subcommand names fail gracefully.</li>
            <li>Test discovery never descends into hidden directories, and a failing JavaScript test file prints its failure message.</li>
            <li>Python <code>zoneinfo</code> resolves timezones; constructing any <code>ZoneInfo</code> previously raised.</li>
            <li>A producer failure mid-body on a streamed HTTP response aborts the response instead of hanging the client.</li>
            <li>macOS/arm64: unwind information is preserved for native frames, so an exception thrown through a native frame no longer aborts; the mach exception port no longer leaks into child processes; and the crash handler is async-signal safe.</li>
            <li>Image compression entrypoints return cleanly instead of failing to link at runtime.</li>
            <li><code>elide install</code> no longer recurses into its own post-install step and deadlocks an npm install.</li>
            <li>Diagnostics carry source identity across the native bridge, logging configuration is safe for concurrent readers, and log levels resolve by longest matching prefix.</li>
            <li>IPC socket writes are flushed to the peer, socket files are unlinked on drop, and a listener only unlinks the socket it bound.</li>
            <li>Builds without Python fail on an empty compile classpath instead of producing many "package does not exist" errors.</li>
            <li>The default container base image is pinned.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="changed">
          <span class="cl-change-tag">Changed</span>
          <ul class="cl-change-list">
            <li>The <code>jib</code>, <code>aube</code>, <code>uv</code>, <code>pro</code>, and <code>s3</code> subcommands are permanently retired, along with the telemetry, cloud, sidecar, and licensing subsystems; their documentation is removed across locales. <code>python</code>, <code>javap</code>, <code>jdeps</code>, <code>javadoc</code>, <code>native-image</code>, and <code>manifest</code> are unaffected.</li>
            <li>Distributions no longer include duplicate or unreachable files.</li>
            <li>Kotlin language and API level are now 2.4.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="chore">
          <span class="cl-change-tag">Maintenance</span>
          <ul class="cl-change-list">
            <li>The Homebrew tap now receives an automatic version bump for each nightly release.</li>
          </ul>
        </section>
      </div>
    </div>
  </details>

  <details class="cl-release">
    <summary class="cl-release-header">
      <span class="cl-release-heading">
        <span class="cl-release-version" role="heading" aria-level="3">1.4.4</span>
      </span>
      <span class="cl-release-summary">Turns <code>elide test</code> into a single cross-language test runner, adds Java language-server support and <code>pom.xml</code> manifests, and moves dependency installation onto the managed toolchain.</span>
    </summary>
    <div class="cl-release-body">
      <div class="changelog-release-links" aria-label="Release links for Elide 1.4.4">
        <a class="changelog-release-link" href="https://elide.help/docs/releases">
          <span class="changelog-release-link-label">Release notes</span>
          <code>1.4.4</code>
        </a>
        <a class="changelog-release-link changelog-release-link-github" href="https://github.com/elide-dev/elide/releases/tag/1.4.4%2B20260824" target="_blank" rel="noopener noreferrer">
          <span class="changelog-github-icon"></span>
          <span class="changelog-release-link-label">GitHub</span>
          <code>1.4.4+20260824</code>
        </a>
      </div>
      <div class="cl-changes">
        <section class="cl-change" data-kind="added">
          <span class="cl-change-tag">Added</span>
          <ul class="cl-change-list">
            <li><code>elide test</code> is now one test runner for every language: JavaScript and TypeScript tests are discovered with no configuration (no <code>elide.pkl</code> required) and run alongside JVM tests as one reported run &mdash; one tally, one exit code, one XML report format, one coverage table.</li>
            <li>JUnit console output uses the build display's format.</li>
            <li><code>elide lsp</code> supports Java, with <code>google-java-format</code> integrated.</li>
            <li><code>pom.xml</code> is accepted as a foreign project manifest.</li>
            <li>Elide's own CI now checks Java and Kotlin formatting with <code>elide format</code>.</li>
            <li>The <code>native-image</code> argument vector is recorded beside image outputs.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="fixed">
          <span class="cl-change-tag">Fixed</span>
          <ul class="cl-change-list">
            <li>TypeScript entry metadata.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="changed">
          <span class="cl-change-tag">Changed</span>
          <ul class="cl-change-list">
            <li>Dependency resolution &mdash; including classifier JARs from Maven Central &mdash; moves off the Elide Classic bootstrap and onto the managed toolchain via <code>elide install</code>.</li>
            <li>JVM code can execute inside the parent <code>elide</code> process; opt in with <code>SPAWN_PROCESS=false</code> in native mode.</li>
            <li><code>TextDecoder</code> uses <code>encoding_rs</code>; URL setters work, <code>XMLHttpRequest</code> accepts <code>data:</code> URLs, and <code>fetch()</code> resolves relative URLs.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="chore">
          <span class="cl-change-tag">Maintenance</span>
          <ul class="cl-change-list">
            <li>Dependency updates across ecosystems include upstream security fixes.</li>
          </ul>
        </section>
      </div>
    </div>
  </details>

  <details class="cl-release">
    <summary class="cl-release-header">
      <span class="cl-release-heading">
        <span class="cl-release-version" role="heading" aria-level="3">1.4.3</span>
      </span>
      <span class="cl-release-summary">Fixes native-image build cache invalidation and makes native Windows builds work.</span>
    </summary>
    <div class="cl-release-body">
      <div class="changelog-release-links" aria-label="Release links for Elide 1.4.3">
        <a class="changelog-release-link" href="https://elide.help/docs/releases">
          <span class="changelog-release-link-label">Release notes</span>
          <code>1.4.3</code>
        </a>
        <a class="changelog-release-link changelog-release-link-github" href="https://github.com/elide-dev/elide/releases/tag/1.4.3%2B20260818" target="_blank" rel="noopener noreferrer">
          <span class="changelog-github-icon"></span>
          <span class="changelog-release-link-label">GitHub</span>
          <code>1.4.3+20260818</code>
        </a>
      </div>
      <div class="cl-changes">
        <section class="cl-change" data-kind="fixed">
          <span class="cl-change-tag">Fixed</span>
          <ul class="cl-change-list">
            <li>Native-image task cache keys now fingerprint the contents of configuration inputs, so editing reachability metadata under <code>-H:ConfigurationFileDirectories</code> or regenerating a profile correctly invalidates the cached image; previously only the flag text was tracked.</li>
            <li>Native-image output and configuration paths are relative to the resolved project root, configuration and linker inputs are fingerprinted through symlinks and external paths, and the complete JVM <code>conf</code> tree &mdash; including <code>java.security</code> &mdash; is packaged.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="changed">
          <span class="cl-change-tag">Changed</span>
          <ul class="cl-change-list">
            <li>Windows builds work natively: the builder no longer forces container mode on Windows and prefers a resolved native binary, postinstall resolves <code>elide</code> from the <code>PATH</code>, and the docs build script runs on an explicit 32 MiB stack.</li>
          </ul>
        </section>
      </div>
    </div>
  </details>

  <details class="cl-release">
    <summary class="cl-release-header">
      <span class="cl-release-heading">
        <span class="cl-release-version" role="heading" aria-level="3">1.4.2</span>
      </span>
      <span class="cl-release-summary">Runs Java and Kotlin sources directly, adds the WHATWG legacy text encodings, and repairs JVM build task-graph behavior.</span>
    </summary>
    <div class="cl-release-body">
      <div class="changelog-release-links" aria-label="Release links for Elide 1.4.2">
        <a class="changelog-release-link" href="https://elide.help/docs/releases">
          <span class="changelog-release-link-label">Release notes</span>
          <code>1.4.2</code>
        </a>
        <a class="changelog-release-link changelog-release-link-github" href="https://github.com/elide-dev/elide/releases/tag/1.4.2%2B20260816" target="_blank" rel="noopener noreferrer">
          <span class="changelog-github-icon"></span>
          <span class="changelog-release-link-label">GitHub</span>
          <code>1.4.2+20260816</code>
        </a>
      </div>
      <div class="cl-changes">
        <section class="cl-change" data-kind="added">
          <span class="cl-change-tag">Added</span>
          <ul class="cl-change-list">
            <li>Java and Kotlin source files run directly with <code>elide run</code>.</li>
            <li><code>elide run</code> executes scripts declared in <code>elide.pkl</code>, <code>package.json</code>, and <code>pyproject.toml</code>.</li>
            <li>Every legacy encoding in the WHATWG Encoding Standard for <code>TextDecoder</code> &mdash; the single-byte families (<code>windows-125x</code>, <code>iso-8859-*</code>, <code>koi8-r/u</code>, <code>macintosh</code>, and others) and the multi-byte CJK encodings (<code>gbk</code>/<code>gb18030</code>, <code>big5</code>, <code>euc-jp</code>, <code>iso-2022-jp</code>, <code>shift_jis</code>, <code>euc-kr</code>) with spec-correct streaming and error semantics.</li>
            <li>A Spring shorthand for JVM dependency declarations.</li>
            <li>Generic XML test reports.</li>
            <li>Elide itself can be built without Python support via <code>--no-python</code>.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="fixed">
          <span class="cl-change-tag">Fixed</span>
          <ul class="cl-change-list">
            <li>Maven dependency resolution now records the full dependency graph instead of a spanning tree, so shared transitive dependencies resolve correctly in multi-scope projects (for example Spring apps).</li>
            <li>JVM build task-graph fixes: <code>javac</code> targeting prefers <code>--release</code> and falls back to the default release when unset, <code>-parameters</code> is always passed, Kotlin tasks only run when Kotlin sources exist, and run-task resources resolve correctly.</li>
            <li>Worker threads now report their real script path via <code>__filename</code>, <code>__dirname</code>, and <code>process.argv</code>, and an entry module that imports itself resolves to a single module instance by canonical path.</li>
            <li>Ctrl+C now interrupts <code>elide init</code>.</li>
            <li>Arguments after <code>--</code> are forwarded to JVM programs resolved from the project manifest.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="changed">
          <span class="cl-change-tag">Changed</span>
          <ul class="cl-change-list">
            <li>Build targets may be named without a prefix.</li>
            <li><code>--no-cache</code> also skips local build state.</li>
            <li>macOS distributions carry all eight executables, and bundled dylibs are ad-hoc signed.</li>
            <li>The documentation site is completely rebuilt.</li>
          </ul>
        </section>
      </div>
    </div>
  </details>

  <details class="cl-release">
    <summary class="cl-release-header">
      <span class="cl-release-heading">
        <span class="cl-release-version" role="heading" aria-level="3">1.4.1</span>
      </span>
      <span class="cl-release-summary">Implements node:net, node:dgram, and node:child_process, adds Python insights, and improves MCP tooling and CLI error output.</span>
    </summary>
    <div class="cl-release-body">
      <div class="changelog-release-links" aria-label="Release links for Elide 1.4.1">
        <a class="changelog-release-link" href="https://elide.help/docs/releases">
          <span class="changelog-release-link-label">Release notes</span>
          <code>1.4.1</code>
        </a>
        <a class="changelog-release-link changelog-release-link-github" href="https://github.com/elide-dev/elide/releases/tag/1.4.1%2B20260719" target="_blank" rel="noopener noreferrer">
          <span class="changelog-github-icon"></span>
          <span class="changelog-release-link-label">GitHub</span>
          <code>1.4.1+20260719</code>
        </a>
      </div>
      <div class="cl-changes">
        <section class="cl-change" data-kind="added">
          <span class="cl-change-tag">Added</span>
          <ul class="cl-change-list">
            <li><code>node:net</code>: TCP and Unix-domain sockets and servers with DNS resolution and Happy-Eyeballs dialing, plus <code>BlockList</code> and <code>SocketAddress</code>.</li>
            <li><code>node:dgram</code>: UDP sockets covering unicast, connected, broadcast, and multicast transports with full socket-option support.</li>
            <li><code>node:child_process</code>: the whole spawn family (<code>spawn</code>, <code>exec</code>, <code>execFile</code>, their sync forms) and <code>fork</code> with a working IPC channel, controlled by new <code>--allow-run</code> / <code>--deny-run</code> sandbox flags.</li>
            <li>Python support in watch insight scripts and targets, plus insight throw hooks, error capture, and argument destructuring.</li>
            <li>The error-stack accessor proposal is now enabled for JavaScript.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="fixed">
          <span class="cl-change-tag">Fixed</span>
          <ul class="cl-change-list">
            <li><code>node:vm</code> contexts now bind <code>this</code> and <code>globalThis</code> to the sandbox and hide the internal contextify marker; <code>node:buffer</code> populates <code>buffer.constants</code> and validates allocation sizes with coded errors; <code>process.argv[1]</code> and <code>__filename</code> resolve to the real script path.</li>
            <li>Python: crash loading the <code>time</code> module, <code>-m</code> module parameter passing, and buffered stdout/stderr now flushing on exit across all eval paths.</li>
            <li>CLI: plain, parseable error output on non-interactive terminals, and the REPL accepts experimental options on language-probe engines.</li>
            <li>Dependency installation: npm overrides no longer corrupt install data, and <code>package.json</code> parsing handles previously failing edge cases.</li>
            <li>MCP and insights: attach failures are reported, in-flight requests are processed when stdio closes, source-path errors are clearer, and deeply nested values render completely.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="changed">
          <span class="cl-change-tag">Changed</span>
          <ul class="cl-change-list">
            <li>The <code>linux-amd64</code> binary runs on older Linux distributions again.</li>
          </ul>
        </section>
      </div>
    </div>
  </details>

  <details class="cl-release">
    <summary class="cl-release-header">
      <span class="cl-release-heading">
        <span class="cl-release-version" role="heading" aria-level="3">1.4.0</span>
      </span>
      <span class="cl-release-summary">Updates the runtime and adds a large set of JavaScript and Python compatibility fixes.</span>
    </summary>
    <div class="cl-release-body">
      <div class="changelog-release-links" aria-label="Release links for Elide 1.4.0">
        <a class="changelog-release-link" href="https://elide.help/docs/releases">
          <span class="changelog-release-link-label">Release notes</span>
          <code>1.4.0</code>
        </a>
        <a class="changelog-release-link changelog-release-link-github" href="https://github.com/elide-dev/elide/releases/tag/1.4.0" target="_blank" rel="noopener noreferrer">
          <span class="changelog-github-icon"></span>
          <span class="changelog-release-link-label">GitHub</span>
          <code>1.4.0</code>
        </a>
      </div>
      <div class="cl-changes">
        <section class="cl-change" data-kind="added">
          <span class="cl-change-tag">Added</span>
          <ul class="cl-change-list">
            <li>Broader Node.js compatibility, including <code>node:path</code>, process behavior, <code>node:assert</code>, <code>node:util</code>, <code>node:test</code>, module shims, stream behavior, and worker-thread support.</li>
            <li>An <code>elide python</code> subcommand with CPython-style flag compatibility.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="fixed">
          <span class="cl-change-tag">Fixed</span>
          <ul class="cl-change-list">
            <li>JavaScript module loading, CommonJS resolution, worker-thread runtime ownership, structured clone and message ports, stream lifecycle behavior, fetch URL resolution, and catchable guest errors for out-of-CWD module failures.</li>
            <li>Embedded native-image operation, embedded JVM staging, Pkl engine isolation, and Python builtins imports.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="changed">
          <span class="cl-change-tag">Changed</span>
          <ul class="cl-change-list">
            <li>NPM platform packages now download the Elide binary during install instead of bundling very large tarballs.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="chore">
          <span class="cl-change-tag">Maintenance</span>
          <ul class="cl-change-list">
            <li>Updated the runtime and toolchain base, the managed toolchains, and the profile-guided optimization configuration.</li>
          </ul>
        </section>
      </div>
    </div>
  </details>

  <details class="cl-release">
    <summary class="cl-release-header">
      <span class="cl-release-heading">
        <span class="cl-release-version" role="heading" aria-level="3">1.3.6</span>
      </span>
      <span class="cl-release-summary">Focuses on installers, dependency installation, JVM tool fixes, MCP improvements, Python layout fixes, and JavaScript conformance hooks.</span>
    </summary>
    <div class="cl-release-body">
      <div class="changelog-release-links" aria-label="Release links for Elide 1.3.6">
        <a class="changelog-release-link" href="https://elide.help/docs/releases">
          <span class="changelog-release-link-label">Release notes</span>
          <code>1.3.6</code>
        </a>
        <a class="changelog-release-link changelog-release-link-github" href="https://github.com/elide-dev/elide/releases/tag/1.3.6%2B20260705" target="_blank" rel="noopener noreferrer">
          <span class="changelog-github-icon"></span>
          <span class="changelog-release-link-label">GitHub</span>
          <code>1.3.6+20260705</code>
        </a>
      </div>
      <div class="cl-changes">
        <section class="cl-change" data-kind="added">
          <span class="cl-change-tag">Added</span>
          <ul class="cl-change-list">
            <li>Packaged installer support around embedded <code>aube</code> for NPM and <code>uv</code> for PyPI, with unified install smoke coverage.</li>
            <li>Local JAR dependencies for JVM projects.</li>
            <li>MCP insight and debugging tools, including project/build inspection and guest-code execution support.</li>
            <li>JavaScript conformance hooks: global <code>print</code>, plain scriptable error output, and <code>$262</code> host API support for Test262 tooling.</li>
            <li>Web templates for <code>elide init</code>.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="fixed">
          <span class="cl-change-tag">Fixed</span>
          <ul class="cl-change-list">
            <li>The docs Examples button, by adding the backing code samples page.</li>
            <li><code>elide run</code> for spawned JVM processes that read from stdin.</li>
            <li>MCP HTTP mode and high-level insight scripting behavior.</li>
            <li><code>javaformat</code> and <code>ktfmt</code> helper handling for <code>@argfile</code> arguments.</li>
            <li>Several installer and snippet-runner issues.</li>
            <li>Embedded <code>javac</code> compatibility with ambient <code>CLASSPATH</code> defaults and DocLint reflection behavior.</li>
            <li>Runtime error reporting for module-resolution failures.</li>
            <li>Python home selection.</li>
            <li>Temporary writes, moved into a dedicated process directory that is freed on exit.</li>
            <li>NPM publishing reliability, by freeing disk space and reporting publish errors.</li>
          </ul>
        </section>
      </div>
    </div>
  </details>

  <details class="cl-release">
    <summary class="cl-release-header">
      <span class="cl-release-heading">
        <span class="cl-release-version" role="heading" aria-level="3">1.3.5</span>
      </span>
      <span class="cl-release-summary">Improves Kotlin and Bazel workflows, adds a fuller Node filesystem implementation, and fixes update and docs behavior.</span>
    </summary>
    <div class="cl-release-body">
      <div class="changelog-release-links" aria-label="Release links for Elide 1.3.5">
        <a class="changelog-release-link" href="https://elide.help/docs/releases">
          <span class="changelog-release-link-label">Release notes</span>
          <code>1.3.5</code>
        </a>
        <a class="changelog-release-link changelog-release-link-github" href="https://github.com/elide-dev/elide/releases/tag/1.3.5%2B20260628" target="_blank" rel="noopener noreferrer">
          <span class="changelog-github-icon"></span>
          <span class="changelog-release-link-label">GitHub</span>
          <code>1.3.5+20260628</code>
        </a>
      </div>
      <div class="cl-changes">
        <section class="cl-change" data-kind="added">
          <span class="cl-change-tag">Added</span>
          <ul class="cl-change-list">
            <li>Java ABI output for mixed Kotlin and Java source sets in <code>elide kotlinc --abi-only</code>.</li>
            <li>Bazel-aware Kotlin compiler diagnostics and project-relative source paths.</li>
            <li><code>node:fs</code> and <code>node:fs/promises</code> support with a filesystem capability sandbox.</li>
            <li>A docs "File an issue" action, with fixed mobile layout for page actions.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="fixed">
          <span class="cl-change-tag">Fixed</span>
          <ul class="cl-change-list">
            <li>Explicit <code>elide kotlinc --plugins=&lt;suite&gt;</code> selections now take precedence.</li>
            <li><code>elide upgrade</code> now downloads the full archive, not only the binary, when resources are needed.</li>
            <li>Docs crawler and discovery files, and robots behavior.</li>
            <li>NPM publishing, by moving <code>@elide-dev/elide</code> publishing into a dedicated, testable workflow.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="changed">
          <span class="cl-change-tag">Changed</span>
          <ul class="cl-change-list">
            <li>Disabled <code>telemetry</code>, <code>cloud</code>, and <code>sidecar</code> by default behind optional Cargo features.</li>
          </ul>
        </section>
      </div>
    </div>
  </details>

  <details class="cl-release">
    <summary class="cl-release-header">
      <span class="cl-release-heading">
        <span class="cl-release-version" role="heading" aria-level="3">1.3.4</span>
      </span>
      <span class="cl-release-summary">Centered on JVM build performance and Kotlin compiler correctness under persistent-worker use.</span>
    </summary>
    <div class="cl-release-body">
      <div class="changelog-release-links" aria-label="Release links for Elide 1.3.4">
        <a class="changelog-release-link" href="https://elide.help/docs/releases">
          <span class="changelog-release-link-label">Release notes</span>
          <code>1.3.4</code>
        </a>
        <a class="changelog-release-link changelog-release-link-github" href="https://github.com/elide-dev/elide/releases/tag/1.3.4%2B20260623" target="_blank" rel="noopener noreferrer">
          <span class="changelog-github-icon"></span>
          <span class="changelog-release-link-label">GitHub</span>
          <code>1.3.4+20260623</code>
        </a>
      </div>
      <div class="cl-changes">
        <section class="cl-change" data-kind="added">
          <span class="cl-change-tag">Added</span>
          <ul class="cl-change-list">
            <li>Kotlin Build Tools API work for Elide JVM builds.</li>
            <li>Pro i18n support.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="fixed">
          <span class="cl-change-tag">Fixed</span>
          <ul class="cl-change-list">
            <li>Kotlin incremental compilation behavior, with digest-driven invalidation, heap sizing, and classpath-default handling.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="chore">
          <span class="cl-change-tag">Maintenance</span>
          <ul class="cl-change-list">
            <li>Cached warm <code>javac</code> classpath state in persistent workers to reduce repeated classpath indexing.</li>
          </ul>
        </section>
      </div>
    </div>
  </details>

  <details class="cl-release">
    <summary class="cl-release-header">
      <span class="cl-release-heading">
        <span class="cl-release-version" role="heading" aria-level="3">1.3.3</span>
      </span>
      <span class="cl-release-summary">Adds Python 3.12 and native compression work, expands NPM distribution infrastructure, and fixes several JVM build and transport issues.</span>
    </summary>
    <div class="cl-release-body">
      <div class="changelog-release-links" aria-label="Release links for Elide 1.3.3">
        <a class="changelog-release-link" href="https://elide.help/docs/releases">
          <span class="changelog-release-link-label">Release notes</span>
          <code>1.3.3</code>
        </a>
        <a class="changelog-release-link changelog-release-link-github" href="https://github.com/elide-dev/elide/releases/tag/1.3.3%2B20260621" target="_blank" rel="noopener noreferrer">
          <span class="changelog-github-icon"></span>
          <span class="changelog-release-link-label">GitHub</span>
          <code>1.3.3+20260621</code>
        </a>
      </div>
      <div class="cl-changes">
        <section class="cl-change" data-kind="added">
          <span class="cl-change-tag">Added</span>
          <ul class="cl-change-list">
            <li>Python interop, Python 3.12 alignment, and <code>sys.argv</code> fixes.</li>
            <li>Native compression for gzip, Brotli, and Zstandard, replacing <code>zstd-jni</code> and <code>brotli4j</code> in the transport path.</li>
            <li>NPM distribution infrastructure for Elide binary packages.</li>
            <li>Publishing infrastructure for <code>@elide-dev/types</code>.</li>
            <li>Roll-up behavior for excessive Kotlin compiler diagnostics.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="fixed">
          <span class="cl-change-tag">Fixed</span>
          <ul class="cl-change-list">
            <li>Python cold start.</li>
            <li>Updated dependencies to address open security alerts.</li>
            <li>zstd JNI class registration on the dynamic dylib path.</li>
            <li>Native-image task output path semantics.</li>
            <li>Kotlin stdlib inclusion when Kotlin sources are present.</li>
            <li>Kotlin compiler API and language-version argument capture.</li>
            <li>Build-cache fingerprint corruption after cache restore.</li>
            <li>External native-image driver selection.</li>
            <li>JVM codegen, so build and version config stay in sync.</li>
            <li>Build-cache file attribute preservation.</li>
          </ul>
        </section>
      </div>
    </div>
  </details>

  <details class="cl-release">
    <summary class="cl-release-header">
      <span class="cl-release-heading">
        <span class="cl-release-version" role="heading" aria-level="3">1.3.2</span>
      </span>
      <span class="cl-release-summary">Improves CLI version reporting and upgrade behavior, fixes Windows installer packaging, and closes Python and native-image resource gaps.</span>
    </summary>
    <div class="cl-release-body">
      <div class="changelog-release-links" aria-label="Release links for Elide 1.3.2">
        <a class="changelog-release-link" href="https://elide.help/docs/releases">
          <span class="changelog-release-link-label">Release notes</span>
          <code>1.3.2</code>
        </a>
        <a class="changelog-release-link changelog-release-link-github" href="https://github.com/elide-dev/elide/releases/tag/1.3.2%2B20260616" target="_blank" rel="noopener noreferrer">
          <span class="changelog-github-icon"></span>
          <span class="changelog-release-link-label">GitHub</span>
          <code>1.3.2+20260616</code>
        </a>
      </div>
      <div class="cl-changes">
        <section class="cl-change" data-kind="added">
          <span class="cl-change-tag">Added</span>
          <ul class="cl-change-list">
            <li>The Elide masthead in <code>elide info</code>.</li>
            <li>Channel and precise-version awareness to <code>elide --version</code> and <code>elide info</code>.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="fixed">
          <span class="cl-change-tag">Fixed</span>
          <ul class="cl-change-list">
            <li>Made <code>elide upgrade</code> channel-aware and cleaned up user-facing upgrade output.</li>
            <li>musl and LTO builds, by restoring Rust memory intrinsics via <code>compiler-builtins-mem</code>.</li>
            <li>License registration pages to use <code>elide pro activate</code>.</li>
            <li>The Windows installer, now syncing the staged Elide home instead of relying on stale hand-enumerated file paths.</li>
            <li>Python stdlib version resolution from the on-disk Python home layout.</li>
            <li>Native-image <code>jdeps</code> resource bundle inclusion for used-dependency reports.</li>
            <li>Docs for multiplex persistent-worker support.</li>
          </ul>
        </section>
      </div>
    </div>
  </details>

  <details class="cl-release">
    <summary class="cl-release-header">
      <span class="cl-release-heading">
        <span class="cl-release-version" role="heading" aria-level="3">1.3.1</span>
      </span>
      <span class="cl-release-summary">Adds <code>jdeps</code>, improves JS crypto support, and fixes Kotlin, Bazel, and formatter regressions.</span>
    </summary>
    <div class="cl-release-body">
      <div class="changelog-release-links" aria-label="Release links for Elide 1.3.1">
        <a class="changelog-release-link" href="https://elide.help/docs/releases">
          <span class="changelog-release-link-label">Release notes</span>
          <code>1.3.1</code>
        </a>
        <a class="changelog-release-link changelog-release-link-github" href="https://github.com/elide-dev/elide/releases/tag/1.3.1%2B20260614" target="_blank" rel="noopener noreferrer">
          <span class="changelog-github-icon"></span>
          <span class="changelog-release-link-label">GitHub</span>
          <code>1.3.1+20260614</code>
        </a>
      </div>
      <div class="cl-changes">
        <section class="cl-change" data-kind="added">
          <span class="cl-change-tag">Added</span>
          <ul class="cl-change-list">
            <li><code>elide jdeps</code>.</li>
            <li><code>node:crypto</code>, Web Crypto digest behavior, and transparent tool passthrough.</li>
            <li>Reference and guide docs for remaining runtime and tooling topics.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="fixed">
          <span class="cl-change-tag">Fixed</span>
          <ul class="cl-change-list">
            <li>Automatic recovery from corrupt Kotlin incremental-compile caches.</li>
            <li>Bazel flags.</li>
            <li>Formatter check-mode output and Kotlin source counting.</li>
            <li>Generated Java projects, so they no longer include Kotlin dependencies.</li>
          </ul>
        </section>
      </div>
    </div>
  </details>

  <details class="cl-release">
    <summary class="cl-release-header">
      <span class="cl-release-heading">
        <span class="cl-release-version" role="heading" aria-level="3">1.3.0</span>
      </span>
      <span class="cl-release-summary">Early installer, project-template, and native-image fixes from the reviewed PR range.</span>
    </summary>
    <div class="cl-release-body">
      <div class="changelog-release-links" aria-label="Release links for Elide 1.3.0">
        <a class="changelog-release-link" href="https://elide.help/docs/releases">
          <span class="changelog-release-link-label">Release notes</span>
          <code>1.3.0</code>
        </a>
        <a class="changelog-release-link changelog-release-link-github" href="https://github.com/elide-dev/elide/releases/tag/1.3.0%2B20260613" target="_blank" rel="noopener noreferrer">
          <span class="changelog-github-icon"></span>
          <span class="changelog-release-link-label">GitHub</span>
          <code>1.3.0+20260613</code>
        </a>
      </div>
      <div class="cl-changes">
        <section class="cl-change" data-kind="added">
          <span class="cl-change-tag">Added</span>
          <ul class="cl-change-list">
            <li><code>elide init</code> template and metadata improvements, including inverted blocks, binary files, and conditional <code>build</code>/<code>test</code>/<code>run</code> invocation support.</li>
          </ul>
        </section>
        <section class="cl-change" data-kind="fixed">
          <span class="cl-change-tag">Fixed</span>
          <ul class="cl-change-list">
            <li>Installer script argument parsing and Unix executable permissions.</li>
            <li>Native-image localization configuration for ICU.</li>
            <li>Missing annotations for Java test compilations.</li>
            <li>A build-time <code>nanoTime</code> value that caused instant timeout behavior.</li>
          </ul>
        </section>
      </div>
    </div>
  </details>

  <details class="cl-release">
    <summary class="cl-release-header">
      <span class="cl-release-heading cl-release-heading-label">
        <span class="cl-release-version" role="heading" aria-level="3">1.0.x &ndash; 1.2.x</span>
      </span>
      <span class="cl-release-summary">Early prerelease lines, archived for reference. They should not be used for new projects.</span>
    </summary>
    <div class="cl-release-body">
      <div class="changelog-release-links changelog-release-links-wide" aria-label="Release links for Elide prereleases">
        <a class="changelog-release-link changelog-release-link-github" href="https://github.com/elide-dev/elide/releases/tag/1.2.0%2B20260612" target="_blank" rel="noopener noreferrer">
          <span class="changelog-github-icon"></span>
          <span class="changelog-release-link-label">GitHub</span>
          <code>1.2.0+20260612</code>
        </a>
        <a class="changelog-release-link changelog-release-link-github" href="https://github.com/elide-dev/elide/releases/tag/1.1.0%2B20260430" target="_blank" rel="noopener noreferrer">
          <span class="changelog-github-icon"></span>
          <span class="changelog-release-link-label">GitHub</span>
          <code>1.1.0+20260430</code>
        </a>
        <a class="changelog-release-link changelog-release-link-github" href="https://github.com/elide-dev/elide/releases/tag/1.0.0-beta10" target="_blank" rel="noopener noreferrer">
          <span class="changelog-github-icon"></span>
          <span class="changelog-release-link-label">GitHub</span>
          <code>1.0.0-beta10</code>
        </a>
      </div>
    </div>
  </details>

  <details class="cl-release">
    <summary class="cl-release-header">
      <span class="cl-release-heading cl-release-heading-label">
        <span class="cl-release-version" role="heading" aria-level="3">Elide Classic</span>
      </span>
      <span class="cl-release-summary">The pre-1.0 code line preserved on the <code>v5</code> branch, useful mainly for understanding older projects pinned to it.</span>
    </summary>
    <div class="cl-release-body">
      <div class="changelog-release-links" aria-label="Release links for Elide Classic">
        <a class="changelog-release-link" href="https://github.com/elide-dev/elide/tree/v5" target="_blank" rel="noopener noreferrer">
          <span class="changelog-release-link-label">Classic branch</span>
          <code>v5</code>
        </a>
        <a class="changelog-release-link changelog-release-link-github" href="https://github.com/elide-dev/elide/releases/tag/1.0.0-beta10" target="_blank" rel="noopener noreferrer">
          <span class="changelog-github-icon"></span>
          <span class="changelog-release-link-label">GitHub</span>
          <code>1.0.0-beta10</code>
        </a>
      </div>
      <p class="cl-classic-note">Classic used beta and release-candidate versions such as <code>1.0.0-beta11-rc6</code>. Treat it as historical unless you are maintaining an existing project on that branch.</p>
    </div>
  </details>

</div>

<div class="border-t border-border/40 my-12"></div>

## About This Page

This page is curated from recent merged changes, plus public release tags on
[`elide-dev/elide`](https://github.com/elide-dev/elide/releases).
Dependency-only, CI-only, and test-only changes are omitted unless they affect
installation, security, packaging, or runtime behavior. Version grouping uses
release milestones where they are set and the public nightly release line
otherwise.