Arciphant

Declare your module structure once — Arciphant turns it into a complete Gradle multi-project build.

Arciphant is a Gradle settings plugin for projects built from many modules that share the same technical structure — moduliths, Clean Architecture, Hexagonal Architecture and friends. Instead of maintaining dozens of include(...) statements and near-identical build.gradle.kts files, you describe that structure once, as a template, directly in settings.gradle.kts:

arciphant {
    val moduleTemplate = template()
        .createComponent(name = "domain")
        .createComponent(name = "application", apiDependencies = setOf("domain"))
        .createComponent(name = "web", dependencies = setOf("application"))
        .createComponent(name = "db", dependencies = setOf("application"))

    module(name = "module-a", template = moduleTemplate)
    module(name = "module-b", template = moduleTemplate)
    module(name = "module-c", template = moduleTemplate)
    module(name = "module-d", template = moduleTemplate)

    bundle(name = "my-app")
}

From this single declaration Arciphant generates the whole multi-project build: 16 component projects plus the bundle project for the deployable app, their folders on disk, and every dependency — test fixtures included. The component projects need no build.gradle.kts at all, and adding a fifth module is one line.

What this replaces in plain Gradle

Mapping the same structure onto a plain Gradle build means 17 include(...) statements and 17 hand-written build scripts (16 components plus the bundle) — all repeating the same architecture rule, kept consistent by hand:

Side-by-side comparison: 16 near-identical build scripts, a settings file with 16 includes and a bundle build script in plain Gradle — versus a single arciphant declaration — The same structure, side by side: plain Gradle versus one `arciphant` declaration.

The architecture rule (“web depends on application, which exposes domain”) is duplicated once per module. It has to be kept consistent manually, test-fixture dependencies come on top, and every new module means copying the whole boilerplate again.

Beyond convention plugins

Convention plugins are Gradle’s own answer to duplicated build logic — and Arciphant builds on them, registering them per component type. But convention plugins deduplicate build logic, not build structure: a plugin does not know which projects exist or how they relate. Even with convention plugins in place, every component still needs its include(...) statement and a build script wiring its project dependencies (test fixtures included), and the architecture rule is still repeated — and kept consistent only by discipline — in every module. Arciphant removes exactly this structural duplication.

Why Arciphant

Templates instead of boilerplate

Define your architecture style once as a template — every module instantiated from it gets the same shape. Introducing a new module is a one-liner.

Dependencies wired automatically

Component dependencies become implementation and api dependencies, shared libraries are exposed to every module, and test-fixture dependencies work out of the box.

The compiler enforces the architecture

Components are separate build units, so code that violates the declared dependencies does not even compile. And framework/library code is only on the classpath of the components that declare it.

Clean package structure

The validatePackageStructure task checks that code lives in the packages your module structure prescribes — no extra tools like ArchUnit needed for the basics.

Start here

Setup

Prerequisites, compatibility and how to apply the plugin.

Quickstart

Create a first Arciphant project from scratch in five minutes.

Concepts

Modules, components, templates and bundles — the building blocks.

Demo projects

A complete example application, once per component layout.

About the project

Arciphant is written in Kotlin, developed by Ergon Informatik AG and released under the MIT License. The publisher does not guarantee active maintenance and further development — we work on the plugin to the extent that we need for our own projects.

The name combines architecture and elephant — the elephant being both a metaphor for a large project and a nod to the Gradle logo.

ergon/arciphantArciphant50