# Kit is a Clojure web template that assembles itself from Integrant and Aero

> Kit is a lightweight, modular framework for production Clojure web applications, distributed as a set of small libraries that are wired together in an EDN configuration file, so the plumbing is a system description rather than hand-written wiring. It suits a team that wants a working Clojure service with database, HTTP and metrics already arranged, and the composition model is the part to learn.

**kit-clj/kit** — Lightweight, modular framework for scalable web development in Clojure

- Repository: https://github.com/kit-clj/kit
- Website: https://kit-clj.github.io/
- Stars: 558 · Forks: 54
- Language: Clojure
- License: MIT
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/kit-clj-kit

## A template that hides the plumbing, not the domain

Kit describes itself as a lightweight, modular framework for scalable production systems, and the goal statement is specific. The goal of Kit is to provide a template for a production Clojure web application. It hides common plumbing that is standard across projects via its libs system, while exposing the code that tends to be customised in the template. That distinction is the whole design. Everything a Clojure service needs and nobody wants to write again, the HTTP server, the connection pool, the migration runner, the metrics registry, is a library. Everything that is specific to your business stays in your own namespace. The project is under the MIT licence, the primary language is Clojure, and the site is kit-clj.github.io, with a repository that holds the template plus the libraries rather than a single application. The last push was on 2026-08-18 and there are no GitHub releases, because the deployable artefacts are the libraries on Clojars and the template on the tooling platforms.

## Integrant and Aero do the composition

The two dependencies explain how the system is put together. Thanks to integrant and aero, the libs are simple skeletons with the bulk of the customization being done in the system configuration EDN file. Integrant is the library that makes a Clojure system describable as data, where each component is a keyword mapping to a constructor function and its configuration, and the whole system is a map you can start, stop and reconfigure. Aero is the library that reads that configuration, and it brings a second capability that matters here, because Aero can read its configuration from a resource, a file, a database or an environment variable. For a deployment that runs the same image in several environments, being able to pull the configuration from outside the jar is the difference between one artifact and several. The consequence for a reader is that the framework is not really Kit so much as a curated set of Integrant components plus a config file that wires them, and you will need to read the Integrant and Aero documentation to use it well.

## Getting a project from the template

The recommended way to create a new Kit application is using deps-new, and there are two routes. The recommended one uses neil, the babashka tool manager:

```bash
brew install babashka/brew/neil
neil new io.github.kit-clj/kit yourname/app
```bash

The other route calls deps-new directly, with the template coordinates and your own name:

```bash
clojure -Sdeps '{:deps {io.github.seancorfield/deps-new {:mvn/version "RELEASE"}}}' \
  -Tnew create :template io.github.kit-clj/kit :name yourname/app
```bash

Both paths produce a project rather than a library, which is worth noting before you start. The template coordinates follow the io.github.kit-clj organisation, and the tools.deps path is the one to reach for if you already have the Clojure CLI. The neil path is easier if you are coming from the babashka ecosystem, and the brew install line is the only system dependency it introduces. There is also a lein-template and a deps-template in the library list, so the project supports a Leiningen based project as well, and the template list shows both.

## Profiles decide which libraries you get

The profile system is the mechanism for choosing a starting point, and it works by adding libraries to the base set. With no profile specified, the default includes kit-core and kit-undertow. The named profiles then add one or more libraries each. The +xtdb profile adds the XTDB library, +hato adds the HTTP client, +metrics adds the metrics library, +quartz the scheduler, +redis the Redis library, +selmer the templating library, +nrepl the nREPL component, and +socket-repl the socket REPL library. The SQL profiles are the interesting set because they compose. The +sql profile adds the default SQL libraries, which are kit-sql-conman, kit-sql-migratus and kit-postgres, and the +conman, +hikari and +migratus profiles add those individually, so you can pick the connection pool and the migration runner independently. The +mysql profile adds the SQL general and MySQL libraries. And +full is the union of the optional set, with the XTDB, HTTP client, metrics, scheduler, Redis, templating, REPL, conman, postgres and migratus libraries. Reading that list tells you the design: the base is deliberately tiny and everything else is opt-in.

## What the libraries actually give you

The library descriptions are the most useful part of the README for deciding whether the set covers your needs. kit-core is the basic utility functions used by some other libraries, which is the foundation rather than a feature. kit-xtdb is a simple binding to connect to an XTDB database node, for the immutable database case. kit-hato is an HTTP client built on hato. kit-nrepl is an nREPL component for use in a running system, for example to connect to a production REPL, which is a genuine operational capability and not a development convenience. kit-metrics is configurable metrics using iapetos, so the metric names and tags are defined in config rather than in code. kit-quartz is a scheduler using cronut as an Integrant binding for Quartz, exposing the cronut API with some extensions for aero and utilities. kit-redis is an extension of core.cache for Redis through carmine, so it plugs into the caching protocol the standard library already defines. And kit-repl is a socket REPL Integrant binding for use in a run. The set covers a service's needs rather than a framework's needs, and each one is a thin adapter over a library that already exists.

## The library set, and what the repository contains

The version table lists the published artifacts on Clojars, and the breadth explains the scope. Beyond the ones already described there are kit-http-kit and kit-jetty for the HTTP server side, kit-nrepl, kit-quartz, kit-redis, kit-repl, kit-selmer for templating, and the SQL family, with kit-sql as the general one, kit-sql-conman for the connection manager, kit-sql-hikari for the HikariCP pool and kit-sql-migratus for database migrations. There are also kit-postgres and kit-mysql for the two drivers, and kit-xtdb. Two more artifacts are generators rather than runtime libraries, with kit-generator and lein-template, and the deps-template listed alongside. The repository itself is small, with a libs/ directory holding the libraries, a build/ directory and a build.clj for the build tooling, a deps.edn and a tests.edn, a bb.edn for babashka tasks, a bin/ directory, a test/ directory and a CHANGELOG.md. The build file is a build.clj rather than a project.clj or a deps.edn alone, which is the tools.build style, and the presence of bb.edn says the project expects babashka to be involved in the development loop.

## Conclusion

Adopt Kit if you want a Clojure service that starts with a sane HTTP layer, database handling, migrations and metrics already wired, and you are happy to express the wiring as EDN rather than as code. Do not adopt it for a library you publish, since the project is a template for applications rather than a library dependency, and note that the component set is built around Integrant and Aero, so adopting it means adopting those two as well. Verify first which profile you need, since the default includes only the core and the Undertow server, that the components you want exist in the library list, and that your Clojure tooling supports the tools.deps and Leiningen paths the template offers.

## FAQ

### What is the Kit framework for Clojure?

It provides a template for a production Clojure web application, hiding common plumbing through its libs system while exposing the code that tends to be customised. The libraries are simple skeletons and the bulk of the customization happens in the system configuration EDN file, thanks to Integrant and Aero.

### How do I create a new Kit application?

With deps-new, either through neil as the recommended route, with brew install babashka/brew/neil followed by neil new io.github.kit-clj/kit yourname/app, or directly with the Clojure CLI and the deps-new template coordinates, using the create task with the template io.github.kit-clj/kit and your own name.

### What do the Kit profiles do?

Each profile adds libraries to the default set, which is kit-core and kit-undertow. The +sql profile adds kit-sql-conman, kit-sql-migratus and kit-postgres, while +conman, +hikari and +migratus add those individually, and +full adds the union of the optional libraries including the HTTP client, metrics, scheduler, Redis, templating, REPL and database ones.

### Which Kit libraries cover the database and operations side?

The SQL family covers it, with kit-sql as the general library, kit-sql-conman for the connection manager, kit-sql-hikari for the HikariCP pool, kit-sql-migratus for migrations, and kit-postgres and kit-mysql for the drivers. On the operations side kit-nrepl provides an nREPL component for use in a running system, and kit-repl provides a socket REPL Integrant binding.

## Sources

- [Issues](https://github.com/kit-clj/kit/issues)
- [kit-clj/kit on GitHub](https://github.com/kit-clj/kit)
- [License: MIT](https://github.com/kit-clj/kit/blob/master/LICENSE)
- [Project website](https://kit-clj.github.io/)
- [README](https://github.com/kit-clj/kit/blob/master/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/kit-clj-kit