What's new in Elide
Everything we've shipped to the runtime — latest first.
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.
Read more →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.
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.
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.
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).
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.
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.
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.
# Live reload, debugger (CDP/DAP), LSP and MCP — all on one portelide dev 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).
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.
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.
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.
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.
# Expose your project to AI agents over the Model Context Protocolelide mcp 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.
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.
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); 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.
amends "elide:project.pkl"name = "my-app"artifacts { ["jar"] = build.jar() ["native"] = build.nativeImage("jar") ["container"] = build.containerImage("native")} 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.
fun main() { val langs = listOf("Kotlin", "TypeScript", "Python") println("Elide runs: ${langs.joinToString()}")} 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.
// Import a Python module directly into TypeScriptimport greet from "./greet.py";console.log(greet.hello("Elide")); 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.
amends "elide:project.pkl"name = "my-app"description = "A polyglot Elide project."dependencies { maven { packages { "com.google.guava:guava:33.4.8-jre" } }} 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.
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.
# npm-compatible installs, powered by Orogene — no node_modules churnelide install react react-dom 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.
import { createServer } from "node:http";import { readFile } from "node:fs/promises";createServer(async (_req, res) => { res.end(await readFile("./index.html", "utf8"));}).listen(3000); 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.
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.
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.
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.
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.
First commit
First commit on Elide
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.