Elide

the next runtime

One binary.
Many languages.
Native performance.

Read the docs →
elide.pkl elide install
amends "elide:project.pkl"

name = "my-app"
local logbackVersion = "1.5.32"

dependencies {
  maven {
    packages {
      "com.google.guava:guava:33.5.0-jre"
      "org.slf4j:slf4j-api:2.0.17"
      "ch.qos.logback:logback-core:\(logbackVersion)"
      "ch.qos.logback:logback-classic:\(logbackVersion)"
    }
  }
}
Installer demo
$ elide install
Hello.ktelide build
// Built-in compiler.

fun greeting(name: String = "Elide") = "Hello, ${name}!"

fun main() {
  val x = 42
  println(greeting() + " The answer is ${x}")
}
Builder demo
$ elide kotlinc -- Hello.kt
elide.pkl
artifacts {
  ["classes"] = new Jvm.Jar {
    sources { "main" }
  }
  ["native"] = new Native.NativeImage {
    from { "classes" }
  }
}
$ elide build :native
5ms cold start on linux
100× faster than Next.js
36× faster than kotlinc
20× faster than javac
faster than CPython
🔒 Memory safe
elide.dev 2026
Next.js
Elide
kotlinc
Elide
javac
Elide
CPython
Elide
~5ms cold start

SSR cold-start benchmarks on Linux x64.

elide.pkl
amends "elide:project.pkl"

name = "my-app"
local logbackVersion = "1.5.32"

dependencies {
  maven {
    packages {
      "com.google.guava:guava:33.5.0-jre"
      "org.slf4j:slf4j-api:2.0.17"
      "ch.qos.logback:logback-core:\(logbackVersion)"
      "ch.qos.logback:logback-classic:\(logbackVersion)"
    }
  }
}
$ elide install
Hello.kt
// Built-in compiler.

fun greeting(name: String = "Elide") = "Hello, ${name}!"

fun main() {
  val x = 42
  println(greeting() + " The answer is ${x}")
}
$ elide kotlinc -- Hello.kt
elide.pkl
artifacts {
  ["classes"] = new Jvm.Jar {
    sources { "main" }
  }
  ["native"] = new Native.NativeImage {
    from { "classes" }
  }
}
$ elide build :native

Kotlin as a first-class citizen. Compiler plugins, KotlinX, and JUnit out of the box. No plugins, no configuration; it just works.

Sample.kt

hello.kt
import kotlinx.serialization.json.Jsonimport 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

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

project.pkl
amends "elide:project.pkl"

name = "my-app"
local logbackVersion = "1.5.32"

dependencies {
  maven {
    packages {
      "com.google.guava:guava:33.5.0-jre"
      "org.slf4j:slf4j-api:2.0.17"
      "ch.qos.logback:logback-core:\(logbackVersion)"
      "ch.qos.logback:logback-classic:\(logbackVersion)"
    }
  }
}
NORMAL project.pkl 16L, 347B
Agents

Elide lets your agents see inside running programs so they can help modify behavior live. An AI agent can test code as it builds, inspect runtime state, and iterate without restarting. The runtime becomes a collaborator, not a black box.

Performance

100x faster than Next.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 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 -
COPIED
Homebrew
$ brew install elide-dev/elide/elide
COPIED
Docker
$ docker run --rm -it ghcr.io/elide-dev/elide
COPIED
GitHub Actions
uses: elide-dev/setup-elide@v3
COPIED