One binary.
Many languages.
Native performance.

Elide is a runtime, compiler and toolchain for JavaScript, TypeScript, Python, Java and Kotlin.

Copy and paste into your agent.

curl -sSL --tlsv1.2 elide.sh | bash -s -

Run on macOS, Linux, or WSL.

elide.pkl

pkl

amends "elide:project.pkl"

name = "my-app"

dependencies {
  maven {
    packages {
      "org.apache.commons:commons-lang3:3.20.0"
    }
  }
}

elide.pkl

elide install --fresh

sh

elide install --fresh
[ 7.2s] ✓ Resolved 11 Maven dependencies (7.1s)
[ 7.2s] ✓ Dependencies installed in 7.2s

Hello.kt

kotlin

// Built-in compiler.

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

fun main() {
  val x = 42
  println(greeting() + " The answer is ${x}")
}

Hello.kt

elide build

sh

elide kotlinc -- -cp . -d out Hello.kt
✅  1 Kotlin sources compiled to `out` (163ms)
elide run Hello.kt
Hello, Elide! The answer is 42

hello.ts

typescript

import greet from "./greet.py";

interface Runtime {
  name: string;
  languages: string[];
}

const elide: Runtime = {
  name: "Elide",
  languages: ["JS", "TS", "Python", "Java", "Kotlin"],
};

console.log(greet.hello(elide.name));
console.log(`It runs ${elide.languages.length} languages.`);

greet.py

python

def hello(name):
    return f"Hello from Python, {name}!"

typescript

import greet from "./greet.py";

interface Runtime {
  name: string;
  languages: string[];
}

const elide: Runtime = {
  name: "Elide",
  languages: ["JS", "TS", "Python", "Java", "Kotlin"],
};

console.log(greet.hello(elide.name));
console.log(`It runs ${elide.languages.length} languages.`);

def hello(name):
    return f"Hello from Python, {name}!"

hello.ts · greet.py

elide --interop run

sh

elide --interop run hello.ts
Hello from Python, Elide!
It runs 5 languages.

typescript


const items = [
  { price: 1200, qty: 2 },
  { price: 800, qty: 1 },
];

test("adds every line", () =>
  assert.equal(subtotal(items), 3200));

test("applies a code", () =>
  assert.equal(discount(3200, "TEN"), 2880));

test("ignores unknown codes", () =>
  assert.equal(discount(3200, "NOPE"), 3200));


class ShippingTest {
  @Test fun freeOverFifty() =
    assertEquals(0, shipping(5000, false))

  @Test fun flatRateBelow() =
    assertEquals(499, shipping(3200, false))

  @Test fun expressCosts() =
    assertEquals(1500, shipping(3200, true))
}

cart.test.mjs · ShippingTest.kt

elide test --coverage

sh

╭Coverage Report───────────────────────────────╮
│ Total · 4 files                              │
│   Statements ━━━━━━━━━━━━━━━━━━── 83/92  90% │
│        Lines ━━━━━━━━━━━━━━━━━━━━ 19/19 100% │
│    Functions ━━━━━━━━━━━━━━━━──── 13/16  81% │
│                                              │
│ JavaScript · 2 files                         │
│   Statements ━━━━━━━━━━━━━━━━━━━━ 14/14 100% │
│        Lines ━━━━━━━━━━━━━━━━━━━━ 10/10 100% │
│    Functions ━━━━━━━━━━━━━━━━━━━━   8/8 100% │
│                                              │
│ Kotlin · 2 files                             │
│   Statements ━━━━━━━━━━━━━━━━━─── 69/78  88% │
│        Lines ━━━━━━━━━━━━━━━━━━━━   9/9 100% │
│    Functions ━━━━━━━━━━━━────────   5/8  62% │
╰──────────────────────────────────────────────╯

 6 pass
 0 skip
 0 fail
Ran 6 tests across 2 files. (1.31s)

36× faster than kotlinc

1.4ms JavaScript startup (Bun: 1.6 ms)

20× faster than javac

5× Node’s requests per second

3× faster than CPython

4.8ms Python startup (CPython: 6.0 ms)

Opt-in sandbox

01Polyglot

Mix languages in one program.

Import Python from JavaScript. Call it like any other module.

checkout.mjs

javascript


const cart = [
  { price: 24, quantity: 2 },
  { price: 12, quantity: 1 },
];

const usd = value => `$${value.toFixed(2)}`;
const total = pricing.quote(cart, usd);

console.log(`Order total: ${total}`);

pricing.py

python

def quote(items, format_money):
    total = sum(
        item.price * item.quantity
        for item in items
    )
    return format_money(total)

Terminal

sh

elide --interop run checkout.mjs
Order total: $60.00

Details

JavaScript imports a Python module, passes it a cart and a live callback, and uses the result where it started. One process. No extra service to build.

Recorded with Elide 1.6.2+1e156135465. Python component: elide setup python. No external packages. Not a benchmark. Playback keeps the original timing.

checkout.mjs pricing.py

Languages

02Insight

Let Claude or Codex see inside your program.

Insight shows any call’s inputs and result. No logging, no code changes.

checkout.js

javascript

function checkoutTotal(subtotal, shipping) {
  return subtotal + shipping;
}

console.log("Checkout total:", checkoutTotal(4200, "500"));

checkoutTotal: subtotal=4200 (number), shipping=500 (string)
Returned: 4200500 (string)

Terminal

sh

elide run --insights=trace.js checkout.js
checkoutTotal: subtotal=4200 (number), shipping=500 (string)
Returned: 4200500 (string)
Checkout total: 4200500

Details

Why did 4,200 + 500 become 4,200,500? Insight prints the arguments and the return value of the call. The application is unchanged. The notes under the source are its recorded output.

Recorded with Elide 1.6.2+1e156135465. No external packages. Not a benchmark. Playback keeps the original timing.

checkout.js trace.js mcp.json

Agentic engineering

03Agents

MCP, directly from the runtime.

One command connects Claude or Codex to your project.

checkout prints 4200500 instead of 4700. trace to find out why.
elide project_context
elide run_snippet
elide run_snippet
elide run_snippet

elide insight_run /tmp/order-summary/checkout.js

checkoutTotal(subtotal: 4200, shipping: "500") → "4200500"
Checkout total: 4200500

The total is 4200500 because shipping arrives as the string "500", so + concatenates instead of adding. …

How it worked

ConnectClaude Code connects to the Elide runtime itself: elide mcp is its only MCP server.
WatchIt asks the runtime to watch the code through the Insight API: watch('checkoutTotal').args() and watch('checkoutTotal').returns().
ReportElide runs checkout.js and reports what it saw back to the agent: checkoutTotal(subtotal: 4200, shipping: "500") → "4200500".

No logging added and no code changed; the agent read the program as it ran.

Details

A real Claude Code session with Elide as its only MCP server, replayed at its recorded speed. elide mcp serves project context, builds, dependencies, docs, tests, coverage, telemetry, and code execution.

Recorded 2026-11-10 with Claude Code 2.1.322 (claude-haiku-5-5) and Elide 1.6.3+1dce7fe60b, non-interactively, in a copy of the toolchain demo project with checkout.js and trace.js. Prompt, tool calls, results, and answer are verbatim; arrival times are the session’s own.

Connect Claude Code with claude mcp add --scope project --transport stdio elide -- elide mcp, or Codex with codex mcp add elide -- elide mcp.

22 tools: agent/context, build/cancel, build/diagnostics, build/graph, build/inspect, build/run, build/status, coverage/report, deps/inspect, docs/read, elide, elide/links, insight/run, project/context, run/file, run/snippet, studio/open, telemetry/read, telemetry/run, telemetry/start, telemetry/stop, tests/reports.

session.jsonl recording.json

MCP guide

04Observability

OpenTelemetry, built in.

Elide’s telemetry joins your app’s in one correlated stream of traces, metrics, and logs. No SDK to install.

server.ts

typescript


const tracer = trace.getTracer("shop");
const stockUrl = "http://127.0.0.1:4319/stock";

export default {
  fetch: () =>
    tracer.("checkout", async (span) => {
      const res = await fetch(stockUrl);
      const { left } = await res.json();
      (`checkout: ${left} left in stock`);
      span.end();
      return Response.json({ left });
    }),
};

GET /checkoutservice checkout · trace 8b75b7b7… · 3.4 ms

ElideYour code

GETserver/checkout → 2003.4 ms
checkoutinternal3.1 ms
GETclient/stock → 2002.6 ms

Logs, on the same trace

3.3 msINFOcheckout: 7 left in stockin checkout

Details

The handler imports the standard OpenTelemetry API and nothing else: Elide is the SDK and the OTLP exporter. Elide records the request’s server span and the fetch client span itself, and they join the spans your code opens in one trace; console lines become log records carrying their span’s ids. Send it all to any OTLP endpoint, or to Sentry, Datadog, Honeycomb, Grafana Cloud, or PostHog.

GET /checkout on Elide 1.6.2+1e156135465, exported over OTLP/JSON with elide serve --port=3000 --otel-endpoint=http://127.0.0.1:4318 --otel-protocol=http/json server.ts; 3 spans (2 from Elide) and 1 log records. One request after a warm-up request. Spans and log records are as Elide exported them over OTLP/JSON; times are microseconds from the start of the trace.

telemetry.json server.ts

OpenTelemetry

05Startup

Start in milliseconds.

A native executable. Hello world in 1.43 ms on Linux amd64.

Elide 1.6.0 1.43 ± 0.06 ms

Bun 1.4.2 1.63 ± 0.18 ms

Deno 2.9.7 6.31 ± 0.3 ms

Node.js 24.21.0 11.7 ± 0.9 ms

Linux amd64 · JavaScript hello world, mean ± one standard deviation. Lower is better.

On macOS (Apple Silicon), Elide starts in about 15 ms.

Elide 1.6.0 4.8 ± 0.3 ms

CPython 6 ± 0.3 ms

24-core Linux workstation · Python hello world, mean ± one standard deviation. Lower is better.

Details

Elide starts as a native executable. Programs that keep running get adaptive optimization from GraalVM.

JavaScript: 2026-10-15 · 24-core AMD Ryzen Threadripper PRO 9965WX, Linux (Linux amd64). Mean of 100 runs after 10 warmups; hyperfine -N -w 10 -r 100. Elide was measured without the optional Python component.

Python: 2026-10-02 · 24-core Linux workstation. Mean; hyperfine -N -w 10. Python component installed. CPython version and measured-run count were not recorded.

macOS (Apple Silicon): Approximate figure supplied by the Elide team; not part of the published benchmark run, which was measured on Linux amd64.

JavaScript benchmark (opens in a new tab)Python benchmark (opens in a new tab)

Benchmark

06Serving

Multiply your serving performance.

Requests run in parallel across contexts, in one process.

Default serving

Elide 1.6.0635,510 requests/s
Deno 2.9.7163,511 requests/s
Bun 1.4.2156,974 requests/s
Node.js 24.22.0 LTS123,519 requests/s

Speed1×

Higher is better. Each dot is 100 responses. Slowed 1000×: 1 ms measured takes 1 s here. Dots cross at the same speed in every lane; only how often they leave differs.

Parallel serving

Elide24 contexts, one process 1.6.010,697,938 requests/s
Deno24 worker isolates 2.9.74,152,202 requests/s
Bun24 processes 1.4.33,573,293 requests/s
Node.js24 cluster workers 24.22.0 LTS2,801,194 requests/s

Speed1×

Higher is better. Each dot is 2,000 responses. Slowed 1000×: 1 ms measured takes 1 s here. Dots cross at the same speed in every lane; only how often they leave differs.

server.mjs

javascript

export default {
  port: 3000,
  hostname: "127.0.0.1",
  fetch() {
    return new Response("Hello, World!");
  },
};

Terminal

sh

elide run --contexts=auto server.mjs

Details

Elide handles requests in parallel across application contexts that share native networking and compiled code: more cores in one process, separate state per context, one runtime to operate. Start with a Request/Response handler; turn on multiple contexts when the service needs parallel execution.

Default serving: One application context per runtime. No pipelining. Same 13-byte response and CPU budget; Elide also uses transport threads. One measured run per runtime; 5-second warmup, 10-second measurement; wrk -t12 -c256 -d10s --latency. 2026-10-15.

Parallel serving: 24 contexts, worker isolates, or workers/processes; HTTP/1.1 pipeline depth 16, 256 connections, 16 load threads. Same URL-parsing workload, nine-byte response, and CPU budget. Elide explicitly uses inline scheduling and io_uring. Loopback experiment; results describe these configurations, not universal limits. Memory savings were not measured. Peak of three runs per configuration; 60-second warmup and 60-second measurement per run.

24-core AMD Ryzen Threadripper PRO 9965WX, Linux. The example demonstrates context sizing; the benchmark uses a URL-parsing handler and additional tuning. Dots cross at the same speed in every lane; only how often they leave differs.

Reproduction package (opens in a new tab)

Benchmark

07Editors

Integrated with your editor.

Extensions for IntelliJ IDEA and VS Code. Sync, run, test, debug, and see coverage.

Sync and the Elide tool window0:18Add a dependency to elide.pkl, sync the change, find it under the module's Dependencies.

Details

The Elide extensions for IntelliJ IDEA and VS Code sync your project, run and test code, debug JVM code, and show coverage. Zed gets Java language services through LSP, and debugging for JavaScript, TypeScript, and Python through DAP.

IntelliJ IDEA (opens in a new tab)VS Code (opens in a new tab)

Editor guides

08Debugging

Profiling, debugging, and coverage, built in.

One flag opens Chrome DevTools on your program, across every language in it.

Chrome DevTools paused at a breakpoint in Elide's polyglot debugger — `elide run --debugger=cdp app.ts`elide run --debugger sample.ts, then Chrome DevTools pauses in TypeScript that calls into Python.0:34

`elide run --debugger=cdp app.ts`elide run --debugger sample.ts, then Chrome DevTools pauses in TypeScript that calls into Python.0:34

Details

The same instruments cover every language in the process: here one Chrome DevTools session pauses TypeScript that calls into Python. Editors attach over DAP; Java and Kotlin take a JVM debugger. Coverage lands in one report for every language, in the terminal and in your editor.

The debugging video is from the architecture deep dive; the coverage clip is from the Elide docs. The terminal's title bar in the recording shows the recording machine's user and host name, as on the deep dive.

Profiling: recorded with Elide 1.6.2+1e156135465; the heat on primes.js is the report’s call count for each function, placed on the line that declares it.

Debugging guide (opens in a new tab)Coverage (opens in a new tab)primes.js

Observability

09Build tools

Integrated with your build.

Elide’s compilers inside Bazel and Gradle builds. Adopt them one target at a time.

Bazel clean rebuilds, rules_elide against the stock JVM rules; median wall-clock seconds, lower is better
Build	Stock rules	rules_elide	Faster by
Java Apache Commons Lang259 production files and a generated consumer graph	7.62 srules_java 9.9.0	3.34 sElide 1.6.2	2.3×
Kotlin rules_elide KotlinBuilder11 production files and a generated consumer graph	30.08 srules_kotlin 2.4.21	20.16 sElide 1.6.2	1.5×

Details

rules_elide builds Bazel’s Java and Kotlin libraries with Elide’s native compilers. The Gradle plugin compiles Java with Elide and can install Maven dependencies. Maven projects can use Elide too.

2026-11-05 · GitHub-hosted Linux runner, 4 vCPUs, 4 Bazel jobs. Bazel 9.3.1, Elide 1.6.2, rules_java 9.9.0, rules_kotlin 2.4.21. bazel clean rebuild with dependencies already downloaded; every runtime target compiles in full. Both sides target Java 21; each Bazel mode runs on a fresh server. Default settings on both sides. Medians of 5 (Java) and 3 (Kotlin) measured samples after one warm-up.

Incremental edits are mixed and are not shown as a win. Implementation-only edits: Commons Lang 1.026 s with rules_java against 1.421 s with Elide defaults; KotlinBuilder 2.226 s with rules_kotlin against 2.063 s with Elide defaults (1.193 s with Elide ABI mode, 1.470 s with rules_kotlin ABI mode). Each report keeps every mode, scenario and regression.

Java report (opens in a new tab)Java CI run (opens in a new tab)Kotlin report (opens in a new tab)Kotlin CI run (opens in a new tab)

Build tools

10Toolchain

One toolchain, from one manifest.

Compile, resolve, format, test, and package. No build script.

elide.pkl

pkl

amends "elide:project.pkl"

name = "order-summary"
version = "1.0.0"

dependencies {
  maven {
    packages {
      
    }
  }
}

jvm {
  main = "demo.OrderKt"
}

src/main/kotlin/demo/Order.kt

kotlin

package demo


@Serializable
data class Order(val items: List<Int>) {
  fun total(): Money =
    Money.ofMinor(USD, items.sum().toLong())
}

fun main() {
  val json = """{ "items": [2400, 1800, 800] }"""
  val order = <Order>(json)
  val (items) = order
  println("${items.size} items, ${order.total()}")
}

Terminal

sh

elide install
[ 95ms] ✓ Resolved 22 Maven dependencies (59ms)
[102ms] ✓ Dependencies installed in 81ms
elide test
[ 27ms] ⇥ Java main compilation skipped (No sources)
[ 28ms] ⇥ Java test compilation skipped (No sources)

demo.OrderTest
✓ totalsEveryItem() [61ms]
✓ handlesAnEmptyOrder() [4ms]


 2 pass
 0 skip
 0 fail
Ran 2 tests across one file. (0.81s)
elide run
[ 24ms] ⇥ Dependencies ready (Up to date)
[ 24ms] ⇥ Kotlin main compilation skipped (Up to date)
[ 24ms] ⇥ Java main compilation skipped (Up to date)
3 items, USD 50.00
[169ms] ✓ JVM main application completed successfully (144ms)
[180ms] ✓ Build successful in 159ms

Details

Compilers, dependency resolution, formatting, tests, and packaging share one project model. This manifest names one Maven dependency (joda-money) and an entrypoint; kotlinx.serialization, the Kotlin compiler, and JUnit need no setup. Install, test, and run follow from it, with no build script. Java and Kotlin are first-class, compiler plugins included.

Recorded with Elide 1.6.2+1e156135465. Toolchains and global dependency cache primed; project outputs removed before capture. Playback at 1×; demonstration timing is not a benchmark.

elide.pkl src/main/kotlin/demo/Order.kt src/test/kotlin/demo/OrderTest.kt

Toolchain

11Deployment

Take your code to more places.

Native executables, containers, and WebAssembly from the same sources.

kotlin

data class Line(
  val item: String,
  val cents: Int,
)

val order = listOf(
  Line("coffee", 2400),
  Line("pastry", 1800),
  Line("tip", 800),
)

fun Line.row(): String =
  item.padEnd(10) + "$cents".padStart(6)

fun main() {
  val sum = order.sumOf { it.cents }
  val lines = order + Line("total", sum)

  lines.forEach { println(it.row()) }
}

amends "elide:project.pkl"

name = "receipt"
jvm {
  main = "ReceiptKt"
}

artifacts {
  ["classes"] = new Jvm.Jar {
    sources { "main" }
  }
  ["native"] =  {
    from { "classes" }
    entrypoint = "ReceiptKt"
    name = "receipt"
    options {
      optimization = "b"
      flags {
        "--silent"
        "-J--enable-native-access=ALL-UNNAMED"
      }
    }
  }
  ["browser"] =  {
    from { "classes" }
    entrypoint = "ReceiptKt"
    name = "receipt-web"
    backend = "wasm-gc"
    runtime = "browser"
    options { optimization = "b" }
  }
}

Terminal

sh

elide build --no-cache native
[ 81ms] ✓ Resolved 8 Maven dependencies (49ms)
[297ms] ✓ Compiled 1 main Kotlin source file (215ms)
[297ms] ⇥ Java main compilation skipped (No sources)
[325ms] ✓ Packaged jar 'classes' (27ms)
[17.2s] ✓ Built native image 'native' (16.9s)
[17.2s] ✓ Build successful in 17.2s
./.dev/artifacts/native-image/receipt
coffee      2400
pastry      1800
tip          800
total       5000

Details

Build Kotlin and Java into native executables, package services as container images, or compile to WebAssembly for the browser; the outputs are declared next to the sources. Here a Kotlin receipt is compiled to a native executable and run directly.

Recorded with Elide 1.6.2+1e156135465. Toolchains and global dependencies primed; project outputs removed and --no-cache disables build artifact reuse. Native compilation uses the C toolchain bundled with Elide. The browser target in the manifest is a configuration example; it requires Binaryen and produces WebAssembly plus a JavaScript loader. Playback at 1×; demonstration timing is not a benchmark.

elide.pkl src/main/kotlin/Receipt.kt

Native images

12Compatibility

Compatibility, continuously tested.

We run the upstream test suites and publish every result.

99.9%

Test262 tests

93.8%

CPython core tests

86.8%

Node.js API tests

99.9%

javac conformance tests

Details

Elide 1.6.0+6e718933f · 2026-10-09. Pass rates among executed tests. Skipped and excluded tests are not counted; known limitations and exact suite revisions are published with the results. Web APIs: 95.9% on WinterTC tests.

Selected Node.js core JavaScript API tests; not native-addon N-API coverage or an npm package pass rate. Selected CPython core tests; not a PyPI package pass rate.

Executed tests, and tests not included in the pass-rate denominator
Suite	Passed	Executed	Skipped	Excluded	Report
Test262 tests	96,235	96,329	7,032	0	Report (opens in a new tab)
CPython core tests	31,404	33,494	1,453	2,970	Report (opens in a new tab)
Node.js API tests	1,194	1,375	83	105	Report (opens in a new tab)
javac conformance tests	3,925	3,928	6	0	Report (opens in a new tab)
WinterTC tests	24,065	25,088	75	3,640	Report (opens in a new tab)

Compatibility matrix

13Quality

Fuzzed, sanitized, and benchmaxxed.

Tested on every change, measured against baselines, and signed at release.

Strong coverage
Continuously fuzzed
Continuous sanitization
Performance regression gates
Continuous microbenchmarking
Optimized down to libc
ThinLTO, PGO, and BOLT
OpenSSF scorecards and badges
SLSA Level 2 or above
Sigstore signatures

Details

Engineering practices, with evidence.
Technique	Why it matters	Evidence
Strong coverage	Give regressions fewer places to hide, with tests across language and native boundaries.	Testing and coverage (opens in a new tab)Myna coverage gates (opens in a new tab)
Continuously fuzzed	Probe unusual inputs automatically to find crashes that ordinary test cases can miss.	Native validation (opens in a new tab)
Continuous sanitization	Catch memory errors and race conditions in instrumented builds, before they become elusive production bugs.	Memory-safety practices (opens in a new tab)
Performance regression gates	Hold startup and serving performance to measured baselines, so improvements don’t quietly slow something else down.	Published benchmarks (opens in a new tab)
Continuous microbenchmarking	Measure hot paths on every change, so a slower parser or allocator shows up before it ships.	Published benchmarks (opens in a new tab)
Optimized down to libc	Tune the whole binary together, compiler and C library included, down to a fully static Linux build.	Static musl build (opens in a new tab)
ThinLTO, PGO, and BOLT	Optimize across the whole program at link time, from real profiles, then lay the binary out again for the hot paths.	Published benchmarks (opens in a new tab)
OpenSSF scorecards and badges	Inspect public security practices for the libraries beneath your application.	Myna · Scorecard 8.3/10 (opens in a new tab)Myna · Silver (opens in a new tab)Toolchain · Gold (opens in a new tab)TruffleCEL · Passing (opens in a new tab)
SLSA Level 2 or above	Trace releases and libraries to their source and build, with signed provenance from hardened publishing workflows.	Hardened JVM publisher (opens in a new tab)
Sigstore signatures	Verify who published a release and that its downloaded bytes match what was signed.	Verify Myna artifacts (opens in a new tab)Verify an Elide download (opens in a new tab)

OpenSSF results are per project, checked November 10, 2026. Scorecard measures automated repository checks; Best Practices badges record project self-assessments.

Testing

14Kotlin

Kotlin as a first-class citizen.

Everything you need built right in: serialization, coroutines, all of KotlinX.

kotlin



data class Order(val id: Int, val cents: Int)

fun main() = runBlocking {
  val orders = (1..3).map { id ->
    async { Order(id, cents = id * 1250) }
  }.awaitAll()
  val total = orders.sumOf { it.cents }

  println(Json.encodeToString(orders.last()))
  println("${orders.size} orders, $total cents")
}

amends "elide:project.pkl"

name = "orders"
version = "1.0.0"

jvm {
  main = "MainKt"
}

kotlin {
  features {
    
    
  }
}

Terminal

sh

elide build
[ 82ms] ✓ Resolved 8 Maven dependencies (49ms)
[ 84ms] ⇥ Kotlin main compilation skipped (From cache)
[ 84ms] ⇥ Java main compilation skipped (No sources)
[ 90ms] ✓ Build successful in 65ms
elide run
[ 26ms] ⇥ Dependencies ready (Up to date)
[ 26ms] ⇥ Kotlin main compilation skipped (Up to date)
[ 26ms] ⇥ Java main compilation skipped (Up to date)
{"id":3,"cents":3750}
3 orders, 7500 cents
[168ms] ✓ JVM main application completed successfully (143ms)
[180ms] ✓ Build successful in 158ms

Details

Kotlin 2.5 and JDK 25 come with Elide, and the common libraries need no setup: the manifest switches on kotlinx.serialization (a compiler plugin) and kotlinx.coroutines by name, and the build compiles and runs it with no plugin blocks or dependency list. Both are on by default; the manifest names them to show where they live. Power Assert and Metro are on by default too.

Recorded with Elide 1.6.2+1e156135465. Bundled Kotlin toolchain and libraries; project outputs removed before capture. Playback at 1×; demonstration timing is not a benchmark.

elide.pkl src/main/kotlin/Main.kt

Elide for Kotlin

15Testing

Delightful, modern, your language: pick three.

One test command. One coverage report. Every language.

src/pricing.mjs

javascript

export function discount(total) {
  return total >= 100 ? total * 0.9 : total;
}

src/pricing.test.mjs

javascript


test("small orders keep their price", () => {
  assert.equal(discount(40), 40);
});

src/main/kotlin/Shipping.kt

kotlin

fun shipping(items: Int): Int =
  if (items >= 3) 0 else 5

src/test/kotlin/ShippingTest.kt

kotlin


class ShippingTest {
  @Test
  fun smallOrdersPayShipping() {
    assertEquals(5, shipping(1))
  }
}

Terminal

sh

elide test --coverage

src/pricing.test.mjs
✓ small orders keep their price [1ms]
[139ms] ✓ Resolved 21 Maven dependencies (100ms)
[139ms] ⇥ Java main compilation skipped (No sources)
[139ms] ⇥ Java test compilation skipped (No sources)

ShippingTest
✓ smallOrdersPayShipping() [22ms]

╭Coverage Report───────────────────────────────╮
│ Total · 4 files                              │
│   Statements ━━━━━━━━━━━━━━━━━─── 16/18  88% │
│        Lines ━━━━━━━━━━━━━━━━━━━━   7/7 100% │
│    Functions ━━━━━━━━━━━━━━━━━━━━   7/7 100% │
│                                              │
│ JavaScript · 2 files                         │
│   Statements ━━━━━━━━━━━━━━━━━━━━   3/3 100% │
│        Lines ━━━━━━━━━━━━━━━━━━━━   3/3 100% │
│    Functions ━━━━━━━━━━━━━━━━━━━━   4/4 100% │
│                                              │
│ Kotlin · 2 files                             │
│   Statements ━━━━━━━━━━━━━━━━━─── 13/15  86% │
│        Lines ━━━━━━━━━━━━━━━━━━━━   4/4 100% │
│    Functions ━━━━━━━━━━━━━━━━━━━━   3/3 100% │
╰──────────────────────────────────────────────╯

 2 pass
 0 skip
 0 fail
Ran 2 tests across 2 files. (1.18s)

Details

One command runs the JavaScript and Kotlin tests, then reports covered statements, lines, and functions together. Tests run across ecosystems, coverage lands in one report, and diagnostics lead back to your code.

Recorded with Elide 1.6.2+1e156135465. Full Elide distribution with JVM tooling. Resolved dependencies and toolchains; fresh project output. Not a benchmark. Playback keeps the original timing.

elide.pkl src/main/kotlin/Shipping.kt src/test/kotlin/ShippingTest.kt src/pricing.mjs src/pricing.test.mjs

Coverage