jrs

A JVM build system, written in Rust.

getjrs.dev

jrs builds, tests, runs and packages a single-module Java project from one jrs.toml manifest, resolving dependencies from Maven Central. Kotlin, Scala and Groovy sources compile alongside the Java ones. It aims for the ergonomics of Cargo: a small manifest, a committed lockfile, one binary, and no build script to write.

Project status

jrs is an experimental, single-module build system, not a replacement for Maven or Gradle. It implements a deliberately narrow subset of what those tools do — there is no plugin system, no build DSL and no multi-module reactor. A project's own build steps are tasks: commands jrs runs as subprocesses at fixed points in its lifecycle, which they cannot replace or reorder. It is offered as-is under the Apache 2.0 licence; evaluate it against your own requirements before adopting it for production builds.

Why jrs

• One native binary, no daemon. The build tool itself starts in milliseconds; the JVM starts only to run javac, your tests and your application.
• Pinned and reproducible by default. Every version and checksum sits in a committed jrs.lock, and two builds of the same inputs produce byte-identical jars, with no configuration.
• No build script to audit. jrs.toml is data, and there are no plugins. Nothing a project writes runs inside jrs; custom steps are tasks, run as subprocesses.
• Packaging built in. Fat jars with correctly merged service and Spring registries, jlink runtimes, jpackage installers, GraalVM native executables and ProGuard, without a plugin each.
• Easy for people and for agents. A manifest you can read in one screen, jrs add / jrs remove, plain output and jrs metadata as JSON.

It fits single-module services (Spring Boot, Ktor), command-line tools, teams for whom the JVM is not their main language, and builds with supply-chain requirements. It does not fit multi-module builds, library publishing or Android. The longer case, and where jrs is not the right choice, is at getjrs.dev/why.

Features

• Dependency resolution from Maven Central and other repositories, with nearest-wins mediation, BOMs and a committed jrs.lock
• Checksum-verified downloads into a shared cache, and an --offline mode
• Kotlin, Scala and Groovy beside Java, each compiler pinned in jrs.lock
• JUnit 4, 5 and 6, Spock, Kotest, ScalaTest and MUnit, with parallel test JVMs, sharding across CI machines, retries, reports and JaCoCo coverage
• Plain, portable and fat jars, distributions, jlink images, jpackage installers, GraalVM native executables and ProGuard obfuscation
• A CycloneDX SBOM beside the jar, a licence report, and a vulnerability audit against the OSV database
• User-defined tasks and lifecycle hooks, with Java tools from Maven Central: formatters and checkers such as google-java-format, ktfmt, Checkstyle, PMD and SpotBugs need no plugin
• One-shot migration from Maven and Gradle, Spring Boot builds included
• Watch mode that rebuilds, retests or restarts the program, dependency trees, outdated reports, jrs add / jrs remove and shell completions

Installation

jrs needs a JDK 17 or newer on PATH, or pointed at by JAVA_HOME. On macOS or Linux:

curl -fsSL https://getjrs.dev/install.sh | sh

or, with a Rust toolchain, from source:

cargo install --git https://github.com/pwittchen/jrs.git

Windows binaries, other versions, manual installation and the setup-jrs GitHub Action are covered in DOCS.md. A prebuilt jrs updates itself: jrs self check says whether a newer release is out, and jrs self update installs it (Updating).

Getting started

jrs init            # scaffold jrs.toml, a starter main class and its test
jrs run             # compile and run
jrs test            # compile the tests and run them
jrs package --fat   # build a self-contained jar

A whole project is one manifest and a source tree:

[project]
name = "my-app"
version = "1.0.0"
main-class = "com.example.Main"

[java]
source = 21

[dependencies]
"com.google.guava:guava" = "33.0.0-jre"

[dev-dependencies]
"org.junit.jupiter:junit-jupiter" = "5.10.2"

To move an existing project over, run jrs migrate next to its pom.xml or Gradle build. examples holds complete sample projects in Java, Kotlin, Scala and Groovy.

Documentation

• DOCS.md — the full reference: the manifest, every command, tests, tasks, JVM languages, configuration and migration; also on the web at getjrs.dev/docs
• ARCH.md — how the code is put together
• SPEC.md — the design behind it
• ROADMAP.md — known gaps and what comes next

Development

cargo build
cargo test

See DOCS.md for the network tests, the benchmarks and the release process.

Licence

Apache License 2.0. See LICENSE.