Docs
Elide elide

The modern runtime.

One binary. Every language. Native performance.

curl -sSL --tlsv1.2 elide.sh | bash -s -
Read the docs →
sample.mts
// use node apis
import { readFileSync } from "node:fs"

// interoperate across languages
import sample from "./sample.py"

const x: number = 42;
console.log(sample.greeting() + ` The answer is ${x}`);
$ elide run sample.mts
sample.py
def greeting(name = "Elide"):
  return f"Hello, {name}!"
$ elide run sample.mts
Hello, Elide! The answer is 42
project.pkl
artifacts {
  // Build a JAR from our code
  ["jar"] = build.jar()

  // Build a native image from our JAR
  ["native"] = build.nativeImage("jar")

  // Wrap in a container — no Docker needed
  ["container"] = (build.containerImage("native")) {
    image = "ghcr.io/elide-dev/samples/containers"
  }
}
$ elide build
elide.dev 2026
execution time →
75x faster than Next.js
Next.js
Elide
36x faster than kotlinc
kotlinc
Elide
20x faster than javac
javac
Elide
3x faster than CPython
CPython
Elide
~5ms cold start

SSR cold-start benchmarks on Linux x64. See methodology.

First-class citizen. No prior build step. KotlinX out of the box. Maven dependencies with zero config.

.kt .kts

hello.kt
import kotlinx.serialization.json.Json
import kotlinx.serialization.Serializable

@Serializable
data class Config(val name: String, val port: Int)

fun main() {
  val config = Json.decodeFromString<Config>("""{"name":"elide","port":3000}""")
  println("Running ${config.name} on port ${config.port}")
}

NORMAL hello.kt 10L, 285B
$ elide run hello.kt
Running elide on port 3000

Pkl as a manifest format. Like package.json or pom.xml, but typed and composable. Maven dependencies resolve automatically.

project.pkl
amends "elide:project.pkl"

name = "elide-test-ktjvm"
description = "Example project using Elide with Kotlin/JVM."

dependencies {
  maven {
    packages {
      "com.google.guava:guava:33.4.8-jre"
    }
  }
}

NORMAL project.pkl 12L, 210B
Performance

75x faster than Node.js isn't a theoretical benchmark. It's what happens when you compile JavaScript to native machine code instead of interpreting it. Same for Python. Same for Kotlin.

Safety

You don't have to rewrite in Rust to get memory safety. Elide sandboxes your existing JavaScript, Python, and JVM code at the runtime level. The safety comes from the runtime, not the language.

Productivity

No more "which Node version." No more "which JDK." No more "which Python." One binary, every language, every developer on the team.

Compatibility

No migration guide because there's nothing to migrate. Same file extensions, same imports, same APIs. Faster output.

Script
$ curl -sSL --tlsv1.2 elide.sh | bash -s -
Homebrew
$ brew install elide-dev/elide/elide
Docker
$ docker run --rm -it ghcr.io/elide-dev/elide
GitHub Actions
uses: elide-dev/setup-elide@v3