[](https://opensource.org/licenses/Apache-2.0)
[](https://www.oracle.com/java/technologies/javase/jdk17-archive-downloads.html)
[](https://rife2.com/bld)
[](https://github.com/rife2/bld/releases/latest)
[](https://central.sonatype.com/artifact/com.uwyn.rife2/bld)
[](https://github.com/rife2/bld/packages/2214741/versions)
[](https://github.com/rife2/bld/actions/workflows/bld.yml)
[](https://github.com/rife2/rife2/actions/workflows/bld.yml)
# What is bld?
`bld` is a build tool that lets you write your build logic in pure Java.
`bld` was created because we're not really interested in build tools. We use
them because we have to, but we'd rather just get on with coding the real stuff.
`bld` is designed with the following principles in mind:
* tasks don't happen without you telling them to happen
* no auto-magical behavior, task behavior is explicit and API-defined
* managing libs yourself is fine, automating that is fine too, or mix and match
* build logic is written in Java, with all the advantages of Java
* standard collection of Java-centric tasks for common operations
* bld is distributed as a single jar, if you have the jar, you have the build system
# Designed for modern Java
`bld` requires Java 17 or later and supports the latest JDK releases. Your
build logic stays concise and readable, and any Java IDE understands it. You
get auto-completion and javadoc documentation, and you can split your build
logic into multiple files and classes when you outgrow a single file.
Here is a complete bld file for a Java application using JUnit 5 for its tests.
Nothing else is needed to be able to run it, test it and distribute it:
```java
package com.example;
import rife.bld.Project;
import java.util.List;
import static rife.bld.dependencies.Repository.*;
import static rife.bld.dependencies.Scope.*;
public class MyAppBuild extends Project {
public MyAppBuild() {
pkg = "com.example";
name = "my-app";
mainClass = "com.example.MyApp";
version = version(0,1,0);
downloadSources = true;
repositories = List.of(MAVEN_CENTRAL, RIFE2_RELEASES);
scope(test)
.include(dependency("org.junit.jupiter", "junit-jupiter", version(6,1,3)))
.include(dependency("org.junit.platform", "junit-platform-console-standalone", version(6,1,3)));
}
public static void main(String[] args) {
new MyAppBuild().start(args);
}
}
```
> **NOTE:** `bld` supports different ways to describe dependencies,
> `dependency("org.junit.jupiter", "junit-jupiter", version(6,1,3))` can for instance also
> be written as `dependency("org.junit.jupiter:junit-jupiter:6.1.3")`. Which format you use,
> is a matter of personal taste.
# Where does `bld` fit?
Maven and Gradle describe a build for the tool to execute. `bld` is ordinary
Java that runs directly.
| | Maven | Gradle | `bld` |
|------------------------------|-------------------|----------------------|---------------------------------------------------|
| Language | XML | Groovy / Kotlin | Java |
| IDE completion & refactoring | limited | with a plugin | full, it's Java |
| Debugging | attach to the JVM | attach to the daemon | the whole Java debugger: breakpoints, watches, .. |
| Extensions | plugins | plugins / DSL | any Java jar, or a `bld` extension |
Writing your build logic in the same language as your application (Java)
reduces the cognitive load, and taking actions immediately without having to
mentally construct a described plan makes it easier to reason about your
build.
# One jar, everything included
Out of the box, `bld` knows how to create, compile, test, document, run,
package and publish your projects. Transitive dependencies are resolved and
downloaded in parallel with live progress reporting, Maven bills of materials
keep versions consistent across your dependency tree, builds run offline when
you want them to, and your artifacts publish straight to Maven Central through
the Sonatype Central Portal.
Modern Java deployment is covered as well, with first-class operations for Java
modules, `jmod`, `jlink` runtime images, `jpackage` native installers, and
annotation processing.
When you need more, there's a growing collection of
[extensions](https://github.com/rife2/bld/wiki/Extensions): Kotlin, Spring
Boot, Checkstyle, PMD, SpotBugs, JaCoCo code coverage, ANTLR4, PIT mutation
testing, TestNG, and many others. Writing your own extension is just writing
Java code.
# Ready for AI agents
Since version 3.0, `bld` can serve your build commands as Model Context
Protocol (MCP) tools. AI coding agents get a structured interface to compile,
test and run your project, with streamed command output and execution
metadata instead of scraped terminal text. Your build stays explicit and
API-defined, agents just get a first-class way to drive it.
```console
./bld mcp install # register the project with Claude Code
./bld mcp install cursor # register with Cursor
./bld mcp install vscode # register with VS Code
```
# IDE support
Since version 2.0, bld comes with its own [IntelliJ IDEA plugin](https://github.com/rife2/bld-idea):
* detect `bld` projects and find their main Java class
* quick access to open and edit the main Java class and wrapper properties of `bld` projects
* list all the commands in `bld` projects in a side panel
* execute one or multiple commands in the order they were selected
* run `bld` commands from icons in the gutter of the build file
* reload the commands in the `bld` project
* automatically reload the commands and dependencies when the build sources or wrapper properties change
* terminate currently running `bld` commands
* `bld` console panel for command output with source code hyperlinking
* display the `bld` dependency tree
* toggle to run `bld` in offline or online mode
* toggle to show the `bld` console when a command is executed
* auto-save all open files before executing a `bld` command
* convenient `bld` one-click cache invalidation
* set `bld` commands to run before or after IDEA compilation
* create custom `bld` command run configuration with options, JVM arguments, and before launch tasks
* assign keyboard shortcuts to `bld` commands
# Find out more
`bld` lets your build logic get out of the way so that you can focus on writing
applications.
Get started immediately by [installing](https://github.com/rife2/bld/wiki/Installation) `bld`
through Homebrew, SDKMAN!, JBang, zip archive, or run it directly from its jar file.
```console
brew install rife2/tools/bld # using Homebrew
sdk install bld # using SDKMAN!
jbang com.uwyn.rife2:bld:3.0.1 # using JBang
```
If you merely want to create a new project, `bld` can also be used by executing this one-liner:
```console
bash -c "$(curl -fsSL https://rife2.com/bld/create.sh)"
```
Or on Windows:
```console
irm https://rife2.com/bld/create.ps1 | iex
```
If you have any questions, suggestions, ideas or just want to chat, feel free
to post on the [forums](https://forum.uwyn.com) or to join us on [Discord](https://discord.gg/zDG6anEXQX).
Read more in the [full documentation](https://github.com/rife2/bld/wiki) and [bld Javadocs](https://rife2.github.io/bld/).
# Contributing
See [CONTIBUTING.md](https://github.com/rife2/bld?tab=contributing-ov-file#readme) for information about
contributing to this project.