Java already carries everything a great build needs - a compiler, the jar as its package format, a
module system, and a language you know by heart. Jenesis takes the platform at its word, and every
tool in the family removes one
more reason to reach for anything else.
The jar describes itself
Java ships its own project descriptor: module-info.java says what a project needs
to build and to run. Jenesis makes it the primary one - it drives compiling, resolving,
packaging and running, you never write a pom.xml again, and every further
advantage of modularity comes for free. POMs keep working quietly underneath - read where a
dependency isn't modular yet, generated where a Maven project consumes yours - just never in
your hands. The destination: a distribution standard built on artifacts that explain
themselves.
Start today, no waiting
Modules and POMs interoperate in both directions: every Maven dependency is one
requires away - a real module where it ships one, an automatic module where it
doesn't - and everything you publish stays consumable from any Maven build. A fully modular
project starts today and reaches exactly as far as each dependency is ready for it, with no
waiting on the ecosystem. And the door is open at every stage: non-modular code stays
first-class, and Jenesis builds classic Maven projects just as happily.
Java is the build language
A build is a short Java program: no foreign DSL to learn, and every tool you already use on
Java - the IDE, the debugger - simply works on your build too. Most projects
write no build code at all: Jenesis infers the build from what is already there, a set of
interdependent jars from your modules and a plugin wherever its configuration file sits in the
project. Anything left to configure is plain Java, plugins are downloaded only for strictly
optional features you opt into, and incremental, parallel and reproducible is the default, not
an achievement.
Secure and self-sufficient
Supply-chain hardening is built in, not bolted on: dependencies are pinned and verified, SBOMs
and vulnerability scans are close at hand, and a build trusts what it can verify rather than
what a remote cache remembers - it runs the same on a laptop as in CI. The build itself ships
as source inside your repository, and a JDK is the only thing it asks for.
Maven Central, ready as modules
The modular world is already stocked. A public catalogue maps every
artifact on Maven Central to its stable module name and serves the whole repository as a true
module layer, so a requires line resolves straight to the artifact behind it. Decades of published Java become ready-to-use modules, today.
Free to enter, free to leave
A module-aware artifact manager that speaks the Maven layout and the
ecosystems around it. Entering is easy in every sense: up and running in minutes on a small,
modern stack with no database to run, and importing from the repository you use today is a
built-in feature. Leaving is treated just as respectfully - you walk out with every artifact
and all of your metadata. And Java is never rationed: no component ceilings and no request
quotas for the artifacts your builds live on.
