Curie is a fast, minimal build tool for Java, Kotlin, and Groovy projects, written in Rust. One Curie.toml file replaces hundreds of lines of POM XML or Gradle DSL — and the binary starts in milliseconds, not seconds.
# Everything Curie needs to build and containerise an app. [application] name = "greeter" version = "0.1.0" [docker] [dependencies] "com.fasterxml.jackson.core:jackson-databind" = "2.17.2" [test-dependencies] "org.junit.jupiter:junit-jupiter" = "5.11.0"
Building greeter v0.1.0 Resolve deps 3 JAR(s) Compile 1 source file(s) [no class files] Compile tests 1 source file(s) Tests ✔ 4 tests successful Package greeter-0.1.0.jar Docker image greeter:0.1.0 (via target/Dockerfile) Run docker run --rm greeter:0.1.0 Hello from greeter.
Maven arrived in 2004 and brought convention over configuration and a centralized repository — genuinely transformative at the time. Twenty years later Curie brings it forward: one Curie.toml replaces hundreds of lines of POM XML, built-in code formatting & security audit, support for modern terminals & color output.
Outputs are deterministic — re-run a build with the same inputs, get a byte-identical JAR. Incremental compilation skips javac when nothing has changed. Workspace members build in parallel by default utilizing all available cores.
A single Curie.toml file captures everything a build needs — no lifecycle phases, no task graph, no DSL. It is easy to read, easy to write, and easy to generate. An AI coding assistant can scaffold, update, and debug a Curie project without needing to understand a plugin ecosystem or a Groovy DSL.
Maven and Gradle solve every problem with a plugin. Curie builds the 80% case — compile, test, package, format, publish, audit, containerise — directly into the binary. Fewer moving parts means fewer version conflicts, fewer classpath surprises, and a complexity ceiling that stays low as your project grows.
| Curie | Maven | Gradle | |
|---|---|---|---|
| Configuration | Curie.toml (~20 lines) — declarative | pom.xml (100+ XML) — declarative | build.gradle — a step back to procedural DSL (declarative syntax planned) |
| Startup | Native binary — instant | JVM cold start (~1–2 s) | Quick, but only if resource heavy daemon already started |
| Incremental builds | Built-in | Plugin-dependent | Built-in but complex |
| Reproducible output | Yes, default | Extra plugin | Extra plugin |
| Docker support | First-class | External plugin | External plugin |
| Maven publishing | curie publish | mvn deploy | publish task |
| Vulnerability scan | curie audit (built-in) | External plugin | External plugin |
| Checksum verification | SHA-256, default | Extra config | Extra config |
Every feature you'd expect from a modern build system — and nothing you wouldn't. Click any element for details.
Curie inherits Cargo's workspace model. Declare members, share BOM imports and Java version once, build in topological order with a single command.
[workspace] members = ["app", "core", "utils"] [java] releaseVersion = "21" [bom-imports] "com.fasterxml.jackson:jackson-bom" = "2.17.2" [test-bom-imports] "org.junit:junit-bom" = "5.11.0"
Workspace . build (3 members) [1/3] utils [2/3] core [3/3] app Resolve deps 7 JAR(s) Compile 12 source file(s) Tests ✔ 27 tests successful Done target/app-0.1.0.jar
Curie honours Maria Skłodowska-Curie (1867–1934), the Polish-born physicist and chemist who discovered polonium and radium, and remains the only person to have won Nobel Prizes in two different sciences. The element Curium (Cm, 96) — already the tool's symbol — was named in her honour. Like her work, Curie the build tool aims to operate at the atomic level: stripping away everything non-essential to expose the stable core underneath.
The name is also a deliberate nod to Cargo, Rust's package manager and build tool. Curie.toml mirrors Cargo.toml. The workspace model and CLI verbs (build, test, publish, new) are borrowed directly from Cargo's playbook. If you already know Cargo, Curie should feel like home — just with a JVM at the centre instead of LLVM.
And if you need one more reading: curiosity — the instinct to ask why Java builds accumulated so much ceremony, and whether any of it was actually necessary.
Building a project shouldn't mean curating dozens of plugins, lifecycles, and XML blocks. Curie makes those choices once — sensible defaults for compilation, testing, packaging, and publishing — and bakes them in. The name carries that promise: a curated build experience where everything that isn't load-bearing has already been swept away.
The core build pipeline works end-to-end — resolve, compile, test, package, optionally containerise. Curie is in active development, with new features and stability improvements shipping regularly.