JAR Tool

Elide ships a native-compiled jar tool — the same implementation as the JDK's jar, but compiled ahead-of-time with GraalVM. This eliminates JVM startup overhead entirely, making JAR assembly near-instant even for scripting and CI pipelines where the JVM cold-start cost would otherwise dominate. It is exposed in two ways:

1. Drop-in replacement — elide jar -- [OPTION...] passes arguments directly to the embedded jar tool with no JVM startup cost.
2. Build system integration — elide build assembles JARs automatically based on artifact declarations in elide.pkl.

A third shortcut — elide javac --jar — compiles Java source and packages the result into a JAR in one step.

---

Drop-in Usage

elide jar -- [OPTION...] [ [--release VERSION] [-C dir] files] ...

Main Operations

Common Modifiers

Examples

Create an archive from two class files:

 elide jar -- --create --file ./classes.jar ./Foo.class ./Bar.class

Create an archive from a directory with a custom manifest:

 elide jar -- --create --file ./classes.jar --manifest ./mymanifest -C ./foo/ .

Create an executable modular JAR:

 elide jar -- --create --file ./app.jar --main-class com.example.Main --module-version 1.0 \
 -C ./build/classes .

Update a non-modular JAR to a modular JAR:

 elide jar -- --update --file ./app.jar --main-class com.example.Main --module-version 1.0 \
 -C ./build/classes module-info.class

Create a multi-release JAR:

 elide jar -- --create --file ./mr.jar -C ./foo classes --release 9 -C ./foo9 classes

List the contents of a JAR:

 elide jar -- --list --file ./app.jar

Extract a JAR into a directory:

 elide jar -- --extract --file ./app.jar --dir ./extracted

---

Build System Integration

When using elide build with an elide.pkl project file, JAR packaging is handled automatically by the build task graph. Three artifact types are supported: classes JARs, sources JARs, and Javadoc JARs.

Declaring Artifacts

Artifacts are declared under the artifacts mapping in elide.pkl. Import elide:Jvm.pkl to access the JAR types:

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

name = "my-library"

sources {
  ["main"] = new Src.SourceSetSpec {
    paths {
      "src/main/java<<>>*.java"
    }
  }
}

artifacts {
  ["app"] = new Jvm.Jar {
    name = "my-library"
    sources { "main" }
  }
  ["sources"] = new Jvm.SourceJar {
    from { "main" }
  }
  ["docs"] = new Jvm.JavadocJar {
    from { "main" }
  }
}

Classes JAR (Jvm.Jar)

Packages compiled .class files from upstream compilation tasks, along with any declared resources, into a single JAR. The manifest is generated automatically and includes Manifest-Version, Created-By, Implementation-Title, Implementation-Version, and Main-Class (if an entrypoint is configured).

artifacts {
  ["app"] = new Jvm.Jar {
    name = "my-app"
    sources { "main" }
    options {
      entrypoint = "com.example.Main"
    }
  }
}

artifacts {
  ["app"] = new Jvm.Jar {
    name = "my-library"
    sources { "main" }
    manifest {
      ["Implementation-Vendor"] = "Acme Corp"
      ["Bundle-SymbolicName"] = "com.example.my-library"
    }
  }
}

artifacts {
  ["app"] = new Jvm.Jar {
    name = "my-app"
    sources { "main" }
    resources {
      ["/config/defaults.properties"] = "src/main/resources/defaults.properties"
    }
  }
}

Sources JAR (Jvm.SourceJar)

Packages source files from the declared source sets into a JAR with a -sources classifier. Commonly used for IDE support and Maven publishing.

artifacts {
  ["sources"] = new Jvm.SourceJar {
    from { "main" }
    excludes { "**/*.generated.java" }
  }
}

Javadoc JAR (Jvm.JavadocJar)

Runs the javadoc tool over Java source files and packages the resulting HTML documentation into a JAR with a -javadoc classifier.

artifacts {
  ["docs"] = new Jvm.JavadocJar {
    from { "main" }
    windowTitle = "My Library API"
    links {
      "https:<<>>
    }
    excludes { "com.example.internal" }
  }
}

---

Compile and Package in One Step

 elide javac --jar < output.jar> [--manifest < manifest-file>] -- <source files...>

The compilation output goes to target/ in the current working directory. The JAR is then assembled from that directory.

 elide javac --jar ./target/app.jar -- ./src/Main.java ./src/Util.java

 elide javac --jar ./target/app.jar --manifest ./src/MANIFEST.MF -- ./src/Main.java