What Elide is

A runtime, compiler, and toolchain.

Elide is one install that compiles your source, runs your programs, and builds your projects. That work usually takes three tools.

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. elide 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.

Elide compiles, tests, and packages Java and Kotlin projects from a short manifest. Your dependencies stay the same, and so do the artifacts you ship.

Developer experience
npm-style CLI
A few commands cover the work: elide install, elide build, elide test, and elide run.
Performance
Millisecond startup
Elide is a native binary, compiled ahead of time.
Configuration
Minimal setup
A short elide.pkl and the standard src/ layout. No build plugins.
Build language
Typed Pkl DSL
Declarative and typed, so mistakes surface before the build runs.
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 2–10 ms ~3 s ~6 s ~10 s
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

Built on open source.

Elide is built from open-source components, listed here.

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.