---
title: Arciphant
description: Declare your module structure once — Arciphant turns it into a complete Gradle multi-project build.
icon: book-open
sidebar:
label: Introduction
seo:
title: Introduction
---
import icon from "../public/icon.svg";
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`:
```kotlin 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.
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:
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](/using-plugins). 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.
:::tip[Is Arciphant for you?]
Arciphant offers the greatest benefit when many modules share the same or a similar technical structure — for example
in a modulith with a Clean, Hexagonal, Onion or Layered Architecture. For a build with a handful of heterogeneous
projects, plain Gradle is just fine.
:::
## Start here
**[Setup](/setup)**
Prerequisites, compatibility and how to apply the plugin.
**[Quickstart](/quickstart)**
Create a first Arciphant project from scratch in five minutes.
**[Concepts](/concepts)**
Modules, components, templates and bundles — the building blocks.
**[Demo projects](/demo-project)**
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 **arc**hitecture and ele**phant** — the elephant being both a metaphor for a large project and a nod
to the Gradle logo.
