v0.1 developer preview · buildwithbarista

A faster pour
for Maven.

Barista is a Maven-compatible build tool for the JVM, written in Rust. The same pom.xml, the same ~/.m2, the same artifacts. A native dependency resolver and a content-addressed cache make resolution fast, and a warm-JVM barback worker pool runs the full Maven build on macOS and Linux.

$brew install buildwithbarista/tap/barista
Install guide

Coming soonHomebrew tap publishes with v0.1 — build from source today →

5.9×
faster compile against warm caches
vs. mvn 3.9.x · walkthrough corpus
14.8%
fewer HTTP requests to Maven Central
cold dependency resolve · measured
46.7%
fewer bytes downloaded on a cold resolve
captured under mitmproxy
01 Speed

Faster, because
we left the JVM.

Resolution moves out of the JVM and into a native resolver with HTTP/2 multiplexing and a content-addressed cache. Execution stays on the JVM — inside a warm barback worker pool that holds Maven 4 core and plugin classloaders across invocations.

mvn 3.9.6 — cold resolve
00.0s
barista pull — cold resolve
00.0s
mvn 3.9.x
23.4s
mvnd 2.x
12.8s
barista
4.4s
Illustrative of the cold-resolve path · Spring Boot starter corpus · measured data →
all measurements → ·  per-iteration data + developer-fixture caveats
02 Pillars

Three things we
care about. That’s it.

Speed gets the headlines. Compatibility is the only reason it can ever ship. Resource efficiency is the reason it’s worth shipping at all.

A native resolver, not the JVM.

Dependency resolution runs in Rust with HTTP/2 multiplexed POM fetching and a real, checksum-verified lockfile. A warm barback daemon holds JIT state and plugin classloaders and runs the full Maven lifecycle on macOS and Linux.

cold resolvetarget ≥5× vs mvn

Built for compatibility.

Reads your existing pom.xml and settings.xml, shares ~/.m2/repository, and bundles Maven 4. The lifecycle drop-ins aim for byte-identical output, modulo declared timestamp normalization.

tested againstmvn 3.9 · 4.0 · mvnd 2.x

Built for the commons.

Maven Central, your corporate Nexus, the mirrors — they’re paid for by someone. Every avoidable request and wasted byte is a bug. Efficiency is a first-class, regression-gated feature.

measured−14.8% requests · −46.7% bytes
03 Vocabulary

The whole menu.
Every verb does one thing.

Barista keeps Maven’s lifecycle verbs and adds a handful of its own for resolution and caching. The signature verbs below plus the Maven lifecycle drop-ins build your project on macOS and Linux today.

pull
Resolve, fetch, lock. Writes a checksum-verified barista.lock.
$ barista pull --update
pour
Materialize locked artifacts into a target — defaults to ~/.m2.
$ barista pour --target ~/.m2
grind
Inspect the resolved graph. (tree today; why / diff / audit landing.)
$ barista grind tree
shot
Run a one-off command on the warm path, skipping needless re-resolution.
$ barista shot --help
dial-in
Interactive wizard to tune the local config: cache, toolchains, workers.
$ barista dial-in

Drop-in surface

The Maven lifecycle phases are mirrored verb-for-verb. On macOS and Linux they execute through the barback daemon, building byte-identically to Maven (single-module proven; reactor maturing; needs a JDK). Windows lifecycle execution is landing — use --no-daemon to fork to Maven there.

  • clean
  • compile
  • test
  • package
  • install
  • verify
  • deploy
  • -P profiles
  • -D properties

Agent-native

Every command supports --output json with a stable, versioned schema. Failures carry structured error codes. No human-shaped output to parse.

  • --output json
  • --output ndjson
  • BAR-CACHE-NNN
  • --ci
  • --frozen
  • --explain
04 Architecture

Orchestration in Rust.
Execution on the JVM.

A clean split between the parts that need to be fast and cold-startable (resolver, cache, classpath builder) and the parts that need to be compatible with the JVM plugin ecosystem (mojo execution). The CLI is a single static binary.

clibaristaRust · single binary · transient
uds / named pipe
daemonbarbackJVM · long-lived · per-toolchain
worker protocol
poolworkersembedded Maven 4 · JIT-warm
http/2 · optional
cacheroasteryREAPI CAS · shared org-wide
http/2
upstreamCentral · Nexus · Artifactoryunchanged

The four processes.

The CLI is transient: it starts, does the work, exits. The daemon stays running across invocations. The cache server is optional and shared. Upstream repositories don’t even know we’re here.

  • 01barista — parse, resolve, lock, materialize. Sub-second on a warm lockfile.
  • 02barback — embedded Maven 4 core in a warm worker pool, plugin classloaders cached. Runs the full lifecycle on macOS and Linux.
  • 03roastery— speaks Bazel’s REAPI CAS gRPC and a barista-native HTTP/2 protocol. Optional org-wide artifact cache.
  • 04upstream — same Central, same Nexus, same Artifactory. Just much less traffic.
05 Commons

Central is a commons.
We treat it like one.

Maven Central serves billions of requests and petabytes of egress every month, paid for by people who are not your problem until they are. Caching is recovery from inefficiency. Barista pursues primary efficiency: don’t ask if you don’t need to ask; don’t transfer what you don’t need to transfer.

Median request count
−14.8% vs mvn 3.9
HTTP/2 multiplexing, conditional requests, and parent-POM deduplication on a cold resolve. Regression-gated — efficiency is a release criterion.
Median bytes downloaded
−46.7% vs mvn 3.9
Avoided redundant metadata and POM fetches, captured under mitmproxy on the walkthrough corpus. Warm-cache builds make zero upstream calls.
Peak concurrent connections
≤6per host · configurable
We are explicitly not trading repository load for our own speed. The ceiling is a default, not a target.
Upstream calls on a warm build
0lockfile fast-path
A valid barista.lock keeps everything local — no metadata polling, no revalidation round-trips.
Caching is recovery from inefficiency. Pursue primary efficiency: don’t ask if you don’t need to ask; don’t transfer what you don’t need to transfer.Design goal · G9 — resource efficiency

Pull your first
resolve in under a minute.

A single static binary — no JVM dependency for the CLI itself. Your existing project resolves and caches with one command.

$brew install buildwithbarista/tap/barista
Read the docs

Coming soon — Homebrew tap publishes with v0.1. Build from source today →