Changelog

What's new in Elide

Everything we've shipped to the runtime — latest first.

Release Mar 12, 2026

Elide 2.0.0-alpha.2 nightly builds

Nightly builds of Elide 2.0.0-alpha.2 begin publishing. Multi-platform support: Linux x86_64 and arm64, macOS arm64, Windows x86_64. Available via curl installer, npm (@elide-dev/elide), Homebrew, APT, and Windows MSI. SHA256 checksums and GPG signatures included.

Feature Mar 10, 2026

Windows support (x86_64)

Elide gains Windows x86_64 support with MSI installer and zip/tgz archives. MSVC-based builds with full platform parity for the CLI runtime.

Feature Mar 5, 2026

Linux arm64 support

Elide adds native Linux arm64 (aarch64) support. Enables deployment on ARM-based cloud instances (AWS Graviton, Ampere) and development on ARM Linux devices.

Feature Mar 1, 2026

Telemetry encryption: X25519/ECIES + AES-128-GCM

Elide implements encrypted telemetry using X25519 Elliptic-curve Diffie–Hellman key exchange with ECIES and AES-128-GCM symmetric encryption, implemented in both Rust (client-side) and Cloudflare Workers (server-side).

Feature Feb 20, 2026

APT repository for Linux distribution

Elide CLI is now available via APT for Debian/Ubuntu-based Linux distributions. Powered by Cloudflare R2 storage and Workers for global distribution. Install with standard apt-get workflow.

Feature Feb 15, 2026

Gradle plugin: up to 20× faster javac compilation

An experimental Gradle plugin that uses Elide's native-image compiled javac to accelerate Java compilation by up to 20×. Drop-in replacement with identical inputs and outputs. Eliminates JIT warmup by pre-compiling the compiler itself. Significant gains for projects under 10,000 classes.

Feature Feb 1, 2026

Unified DevServer: CDP + DAP + LSP + MCP over one port

WHIPLASH introduces a unified development server that multiplexes Chrome DevTools Protocol, Debug Adapter Protocol, Language Server Protocol, and Model Context Protocol over a single WebSocket port. One connection for debugging, language intelligence, and AI agent integration.

Terminal
# Live reload, debugger (CDP/DAP), LSP and MCP — all on one portelide dev
Feature Jan 15, 2026

WHIPLASH: Rust-based systems toolchain layer

Elide introduces WHIPLASH, a Rust-based toolchain and runtime system. Includes a custom musl toolchain with mimalloc allocator, static linking for fully self-contained binaries, and a Cap'n Proto JNI bridge for high-performance Java↔Rust FFI. Cross-platform: Linux (glibc + musl, x86-64 + arm64), macOS (arm64), Windows (MSVC).

Update Dec 23, 2025

TypeScript.fm podcast: Elide runtime deep dive

Sam Gammon appears on TypeScript.fm with Kamran Ayub and Erik Onarheim to discuss the Elide runtime. Topics include cross-language imports, GraalVM internals, how TypeScript can import Python modules, and consolidating multiple backends into one unified runtime.

Release Oct 30, 2025

Beta 10: Python HTTP serving, JDK 25, Kotlin 2.2

Elide's 10th beta adds native Python HTTP serving, crypto.randomUUID(), and progress animations. Supports JavaScript up to ECMA2024, Python 3.12, Kotlin up to 2.2.20, and Java up to JDK 25. Web builder for static sites using Markdown, SCSS/CSS, and TypeScript/JavaScript. `elide serve` for static file serving.

Release Jul 1, 2025

Beta 9: S3 support, v2 test runner, supply chain security

Elide's 9th beta adds built-in S3 support for cloud storage operations and a new v2 test runner. Releases are GPG-signed, published to Sigstore, and partially compliant with SLSA Level III. CycloneDX SBOMs are generated for each platform build.

Feature Apr 15, 2025

Built-in MCP server: `elide mcp`

Elide ships a native Model Context Protocol server. Running `elide mcp` starts a stdio MCP server that Claude and other AI agents can use to interrogate project structure, dependencies, and configuration. Projects created with `elide init` are pre-configured for MCP.

Terminal
# Expose your project to AI agents over the Model Context Protocolelide mcp
Release Apr 1, 2025

Beta 8: static websites, MCP server, IDEA plugin

Elide's 8th beta brings new support for static websites, Kotlin Power Assert, and an experimental IntelliJ IDEA plugin. Node API coverage improves with node:util and node:querystring. Introduces `elide mcp` — a built-in MCP server that gives AI agents knowledge about your project. Kotlin, Rust, and GraalVM all updated to new stable versions.

Feature Nov 1, 2024

Embedded SQLite integration

Built-in SQLite support allows database operations directly within the Elide runtime. No external database server required for local development or embedded use cases.

db.ts
import { DatabaseSync } from "node:sqlite";const db = new DatabaseSync(":memory:");db.exec("CREATE TABLE users (id INTEGER, name TEXT)");db.prepare("INSERT INTO users VALUES (?, ?)").run(1, "Ada");const rows = db.prepare("SELECT * FROM users").all();console.log(rows);
Feature Oct 1, 2024

Native binary and container image builds

The `elide build` command produces JARs, GraalVM native images, and OCI container images in a single pipeline. Container images are built without Docker — configured via Pkl manifest artifacts block with direct registry push support.

elide.pkl
amends "elide:project.pkl"name = "my-app"artifacts {  ["jar"] = build.jar()  ["native"] = build.nativeImage("jar")  ["container"] = build.containerImage("native")}
Feature Sep 1, 2024

Kotlin as a first-class runtime language

Elide can run Kotlin with no prior build step, build Java code identically to javac, and build Kotlin code identically to kotlinc. KotlinX libraries (serialization, coroutines, datetime) are supported out of the box with no dependency installation.

Main.kt
fun main() {  val langs = listOf("Kotlin", "TypeScript", "Python")  println("Elide runs: ${langs.joinToString()}")}
Feature Aug 1, 2024

Cross-language module imports

Elide enables importing modules across language boundaries. TypeScript can import Python modules, and vice versa — with transparent interop handled by the runtime. A single project can mix .mts, .py, .kt, and other files with unified dependency resolution.

main.ts
// Import a Python module directly into TypeScriptimport greet from "./greet.py";console.log(greet.hello("Elide"));
Feature Jul 1, 2024

Pkl project manifests (elide.pkl)

Elide adopts Apple's Pkl as the project manifest format. elide.pkl serves as the equivalent of package.json or pom.xml — declaring dependencies, build scripts, and project metadata in a type-safe, programmable configuration language.

elide.pkl
amends "elide:project.pkl"name = "my-app"description = "A polyglot Elide project."dependencies {  maven {    packages {      "com.google.guava:guava:33.4.8-jre"    }  }}
Feature Jun 1, 2024

Host environment isolation and sandboxing

Elide isolates host environment, I/O, and other sensitive operations from runtime code by default. Security-first design with a granular permission model for controlling access to the filesystem, network, and environment variables.

Feature May 1, 2024

Embedded Orogene: npm-compatible package manager

Orogene is embedded directly into the Elide binary for JavaScript package installation. Running `elide install` resolves and installs npm packages without requiring a separate package manager.

Terminal
# npm-compatible installs, powered by Orogene — no node_modules churnelide install react react-dom
Feature Apr 1, 2024

Node.js API compatibility layer

Elide implements Node.js API shims including node:fs, node:path, node:util, node:querystring, and more. Enables existing Node.js code to run on the Elide runtime with minimal or no changes.

server.ts
import { createServer } from "node:http";import { readFile } from "node:fs/promises";createServer(async (_req, res) => {  res.end(await readFile("./index.html", "utf8"));}).listen(3000);
Feature Jun 1, 2023

Static site generation (SSG)

Elide gains the ability to compile applications to static HTML via SSG. The Elide project website itself is built using this SSG capability.

Feature Apr 1, 2023

Elide CLI: native-image compiled command-line tool

The `elide` CLI binary ships as a GraalVM native-image compiled executable. Instant startup, no JVM required at runtime. Makefile targets for building and installing locally.

Update Mar 1, 2023

Pivot from meta-framework to standalone runtime

Elide evolves from a Kotlin/Multiplatform application framework into a standalone CLI runtime. GraalVM polyglot execution becomes the core product rather than an integration feature. The elide binary is compiled via native-image for instant startup.

Feature Apr 1, 2022

GraalVM polyglot execution: JS, Ruby, Python, LLVM

Elide leverages GraalVM's polyglot capabilities for cross-language execution, including JavaScript, Ruby, Python, and LLVM-based languages running together on a single JVM instance.

Feature Mar 1, 2022

Streaming SSR with React + Kotlin/JS on GraalVM

Server-side rendering of React UIs via Kotlin/JS running on GraalVM. Both CSR (client-side rendering) and SSR (server-side rendering) modes supported natively. Enables isomorphic rendering where the same React code runs on the server and in the browser.

Update Jan 1, 2022

First commit

First commit on Elide

Feature Jun 1, 2019

GraalVM native image support (v1)

Elide v1 gains the ability to leverage GraalVM to compile applications into native binaries, eliminating the need for a JVM or Python runtime in application containers. First integration of GraalVM into the Elide project.