What Elide is

## A runtime, compiler, and toolchain.

Elide is an all-in-one platform that spans the full software development lifecycle. A single distribution compiles source, executes services, and orchestrates builds, consolidating responsibilities that traditionally require three separate toolchains into one cohesive product.

Runtime

One runtime for JavaScript, TypeScript, and Python, with Java and Kotlin compiled and run on a bundled JDK 25\. Node programs, `node:*` modules, and npm packages run directly, and `fetch` uses a native transport built on `epoll`, `io_uring`, or `kqueue`. With `--interop`, JavaScript, TypeScript, and Python call each other in one process, and JavaScript imports WebAssembly directly.

Compiler

Built-in compilers for Java 25 and Kotlin 2.5, with no separate JDK install. GraalVM Native Image compiles JVM applications into standalone executables that need no JVM in production. TypeScript runs with its types stripped, without a `tsconfig.json`; run `tsc` through Elide to type-check. `elide javac` and `elide kotlinc` take the usual compiler flags after `--`.

Toolchain

A single CLI for dependency resolution, builds, container image assembly, and local development. Build definitions are declarative and typed, authored in Pkl. Maven builds run with `elide mvn`, Bazel can use Elide's compilers as persistent workers, and `elide adopt` migrates Maven and Gradle projects.

JVM Toolchain

## A modern toolchain for the JVM.

The JVM underpins a significant share of enterprise software, yet its traditional build tooling carries meaningful configuration and startup overhead. Elide provides a modern alternative without requiring teams to leave the ecosystem: same artifacts, same dependencies, substantially faster feedback loops.

Developer experience

Familiar NPM-style CLI

A minimal command surface with a refined terminal interface.

Performance

Millisecond startup

Ahead-of-time compiled via GraalVM Native Image.

Configuration

Minimal setup

Convention over configuration: a short elide.pkl and the standard src/ layout. No plugins.

Build language

Typed Pkl DSL

Declarative by default, imperative when needed, safe to refactor.

Compatible by default

## Same inputs. Faster everything.

Elide works with your existing Java and Kotlin code and Maven dependencies. Run Maven builds with `elide mvn`, or move Maven and Gradle builds to `elide.pkl` with `elide adopt`. Only faster.

| Feature            | Elide       | Maven    | Gradle       | Bazel      |
| ------------------ | ----------- | -------- | ------------ | ---------- |
| Cold start         | \~30ms      | \~3s     | \~6s         | \~10s      |
| Config format      | Pkl (typed) | XML      | Groovy / KTS | Starlark   |
| No build plugins   | ✓           | ×        | ×            | ×          |
| Native compilation | ✓           | ×        | ×            | ×          |
| Container images   | Built-in    | Plugin   | Plugin       | rules\_oci |
| Multi-language     | ✓           | JVM only | JVM only     | ✓          |
| Learning curve     | Minimal     | Steep    | Steep        | Very steep |

Foundations

## An open, production-grade foundation.

Elide integrates mature open-source components that the industry already depends on, then delivers them through a unified interface. Each foundational technology is listed below for transparency and to invite review.

GraalVM Native Image

Polyglot VM and ahead-of-time native compiler from Oracle Labs

Truffle

Language implementation framework enabling cross-language interoperability

OXC

Rust-based JavaScript and TypeScript toolchain for parsing and transpilation

Pkl

Typed, declarative configuration language from Apple

Rust

Native core for I/O, networking, cryptography, and platform primitives

Kotlin

Primary language for runtime subsystems and guest-language bindings

SQLite

Embedded relational database used throughout the toolchain

mimalloc

High-performance memory allocator from Microsoft Research

About

# A brief history of runtimes

Every decade, a new abstraction makes software faster to write and slower to run.  
Elide breaks that pattern.

1970s

## Machine Code & Assembly

Software written directly for hardware. Maximum performance, zero portability. Every machine was an island.

1972

## C & Unix

Ritchie and Thompson proved systems software could be portable without being slow. C became the lingua franca.

1991

## Java & Python

Virtual machines and interpreters traded performance for productivity. Enterprise chose Java. Scientists chose Python. The split began.

2008

## Chrome & V8

Google proved interpreted languages could be fast with JIT compilation. Node.js followed. Everyone started writing servers in a browser language.

Now

One binary. Your favorite language. Native performance.

Source: https://elide.dev/about