Java and Kotlin with Elide

Install Elide, then choose a template below. Each creates a new project directory with a program and a test.

mkdir hello-kotlin
cd hello-kotlin
elide init --plain --skip-defaults --skip-run --template ktjvm
elide run

mkdir hello-java
cd hello-java
elide init --plain --skip-defaults --skip-run --template java
elide run

Both programs print:

Hello Elide!

Run the generated test with elide test. To use a library, declare its Maven dependency in elide.pkl, then:

elide install
elide test
elide run

Already have a project? Keep Maven/Gradle and use Elide's compiler or JDK, or migrate your build to elide.pkl.

Call a bundled language tool directly when you have one focused job, or use an Elide project when dependencies, tests, and outputs need to be shared. Both approaches use the same binary.

This project declares one Java entrypoint, mixed-language main and test source sets, and three publishable JAR artifacts. Java and Kotlin share the same source-set classpaths automatically.

amends "elide:project.pkl"
import "elide:Jvm.pkl" as Jvm
import "elide:Sources.pkl" as Sources

name = "order-report"

jvm {
  main = "shop.Main"
}

sources {
  ["main"] = new Sources.SourceSetSpec {
    paths {
      "src/main/kotlin/**/*.kt"
      "src/main/java/**/*.java"
    }
  }
  ["test"] = new Sources.SourceSetSpec {
    paths {
      "src/test/kotlin/**/*.kt"
      "src/test/java/**/*.java"
    }
  }
}

artifacts {
  ["app"] = new Jvm.Jar {
    name = "order-report"
    main = "shop.Main"
    sources { "main" }
  }
  ["sources"] = new Jvm.SourceJar {
    sources { "main" }
  }
  ["docs"] = new Jvm.JavadocJar {
    sources { "main" }
  }
}

The default build compiles non-test source sets and produces their configured artifacts. Tests compile against main outputs and execute with JUnit Platform.

elide project info       # Confirm the detected project and entrypoint
elide install            # Resolve declared Maven dependencies
elide build --inspect    # List generated tasks and task options
elide build              # Compile main sources and produce default artifacts
elide test               # Compile tests and run them with JUnit Platform
elide run                # Build as needed, then launch shop.Main

package shop

import java.math.BigDecimal
import kotlin.test.Test
import kotlin.test.assertEquals

class OrderTotalsTest {
  @Test
  fun `summarizes quantities and prices`() {
    val summary = OrderTotals.summarize(
      listOf(
        LineItem("paper", 3, BigDecimal("7.50")),
        LineItem("ink", 2, BigDecimal("18.25")),
      ),
    )

    assertEquals(5, summary.itemCount)
    assertEquals(BigDecimal("59.00"), summary.subtotal)
  }
}

Elide also exposes the rest of its JVM toolchain directly. Prefix the familiar tool with elide, then put its native arguments after the separator.

• Run compiled classes

  Launch a JVM entrypoint with the bundled Java runtime.

  elide java -- -cp target app.Main

• Generate API docs

  Generate Javadoc using the standard command-line options.

  elide javadoc -- -d docs src/main/java/app/Main.java

• Inspect bytecode

  Disassemble a compiled class while debugging build output.

  elide javap -- -classpath target -c app.Main

• Build a native executable

  Compile a JVM application ahead of time to a native executable.

  elide native-image -- -cp app.jar app.Main

Programs run on the bundled JDK with the Kotlin standard library, bundled kotlinx libraries, JUnit for tests and Elide's annotations; see JVM APIs. There is no Elide runtime API, no calls into JavaScript or Python, and no OpenTelemetry API, agent or trace context; add the OpenTelemetry Java SDK yourself, and see OpenTelemetry for the spans elide build and elide test export.

This example puts a Kotlin model and calculation beside a Java entrypoint in one main source set. Elide compiles both languages, connects their classes, and runs the Java entrypoint.

package shop

import java.math.BigDecimal

data class LineItem(
  val sku: String,
  val quantity: Int,
  val unitPrice: BigDecimal,
)

data class OrderSummary(
  val itemCount: Int,
  val subtotal: BigDecimal,
)

object OrderTotals {
  @JvmStatic
  fun summarize(lines: List<LineItem>): OrderSummary = OrderSummary(
    itemCount = lines.sumOf { it.quantity },
    subtotal = lines.fold(BigDecimal.ZERO) { total, line ->
      total + line.unitPrice.multiply(line.quantity.toBigDecimal())
    },
  )
}

package shop;

import java.math.BigDecimal;
import java.util.List;

public final class Main {
  public static void main(String[] args) {
    var lines = List.of(
        new LineItem("paper", 3, new BigDecimal("7.50")),
        new LineItem("ink", 2, new BigDecimal("18.25")),
        new LineItem("labels", 4, new BigDecimal("3.10"))
    );

    var summary = OrderTotals.summarize(lines);

    System.out.printf(
        "%d items · $%s subtotal%n",
        summary.getItemCount(),
        summary.getSubtotal()
    );
  }
}