Demos

Every feature below is a **self-contained project you can clone and run**. Each carries its own `build/jenesis/` sources, so `java build/jenesis/Project.java` from the demo folder builds it. A few that customise or drive the build themselves ship a `build/Demo.java` to run instead; each demo's own README says which. They are numbered as a progression: the early ones establish the basics, the later ones go into specifics. Browse them on GitHub:

Getting started

The four foundational project shapes - start here.

Java (Maven layout) A single-module Java project in the classic Maven layout.
Java (modular layout) The same, as a real Java Module System module with a module-info.
Multi-module (Maven) Several Maven-layout modules built together.
Multi-module (modular) A multi-module modular project and its module graph.

Executables & packaging

Turning a project into something you can ship and run - and running what somebody else shipped.

Executable (Maven) A runnable Maven project packaged with jpackage, plus bundle, launcher jar, and a container context.
Executable (modular) The same for a module: an app image, a .jmod and jlink runtime, a bundle, a launcher jar, and a Dockerfile.
Bundle Ship only the jars as a bundle.zip and run them on a stock JRE.
jlink & jpackage A custom .jmod carrying extra content, linked into a runtime and packaged into an app.
Native image A GraalVM native binary built end to end, with reachability metadata captured from the tests.
Publishing A Maven Central ready bundle - POM metadata, sources and javadoc jars - resolved back to prove it.
Running a released program jpx installs and launches a published tool - named as a module and as a coordinate, pinned and hash-verified.

JVM languages

Kotlin, Scala and Groovy - alone, mixed with Java, and with quality tooling.

Kotlin A Kotlin (and mixed Java/Kotlin) project.
Kotlin quality Kotlin with formatting and static-analysis checks.
Kotlin compiler plugin Enabling a Kotlin compiler plugin.
Scala A Scala (and mixed Java/Scala) project.
Scala quality Scala with code-quality checks.
Groovy A Groovy (and mixed Java/Groovy) project.
Groovy quality Groovy with code-quality checks.

Quality & testing

Keeping a codebase healthy and tests fast.

Code quality Formatting and static analysis for Java.
Code coverage Measuring test coverage.
Test selection Running only the tests a change can affect.
Mutation testing Mutation testing with PIT, switched on by its configuration file.

Supply chain & security

Knowing, pinning and governing what your build depends on.

SBOM Generating a software bill of materials.
Dependency licensing Checking dependency licences against policy.
Vulnerabilities Scanning dependencies for known vulnerabilities.
Bills of materials Importing a Maven BOM and a local pin file, and publishing a BOM of the module's own closure.
Supply-chain security Strict pinning and checksum verification, proven by getting both wrong on purpose.

The module system

Working with the Java Module System in earnest.

Multi-release JAR A multi-release jar that ships a Java 25 override of one class beside its Java 21 baseline.
Pure modular layout A strictly modular layout that resolves by module name and emits no POM.
Module classifier Pinning a classified variant of a module.
Module alias Giving a plain jar a module name, then rewriting the closure into named modules so jlink accepts it.
Platform guard Selecting a dependency variant per platform.
Platform guard (Maven) The platform guard in a Maven layout.

Build customisation

Reaching past the defaults.

Compiler arguments Passing custom arguments to javac.
Annotation processing Running an annotation processor.
Build profiles Switching configuration with profiles.
Java agents Attaching agents to the test run and to the application run.
Exclusions Dropping an unwanted transitive, in a POM and with a tag.
Custom assembler Wrapping the stock assembler so sources are preprocessed before they compile.
Custom Maven build Driving a multi-module Maven-layout build from your own entry point with the convenience factory.
Custom modular build The same for a modular project.
Custom build A code-generating build graph wired entirely by hand.
Internal build module A reusable build plugin compiled from local source.
External build module The same plugin resolved as a published coordinate.
Docker isolation Confining the build and the launched program in a throwaway container.
Build cache Sharing build outputs through a cache.

Cloning the whole repository gives you all of them at once, plus Jenesis itself as the largest worked example. See Getting started to install the tool first.