Katalyst

A convention-driven backend framework for Kotlin and Ktor. Spring Boot's developer experience, the Kotlin way.

Katalyst gives a Ktor service the things you would otherwise wire by hand: dependency injection, YAML configuration, Exposed + HikariCP persistence, transactions, database migrations, a scheduler, an in-process event bus, WebSockets, and first-class testing helpers. You declare components by implementing an interface and point Katalyst at your package — it discovers, validates, orders, and injects everything at startup.

fun main(args: Array<String>) = katalystApplication(args) {
    engine(NettyServer)
    beanEngine(KoinBeanEngine)
    features {
        enableYamlConfiguration()
        enableServerTuning()
        enableEvents()
        enableMigrations()
        enableScheduler()
        enableWebSockets()
    }
    database { fromConfiguration() }
    scanPackages("com.example")
    schema { validateOnStartup() }
}

That is the entire bootstrap. Services, repositories, routes, event handlers, and scheduled jobs under com.example are found and wired automatically — no annotations, no module files.

Status

Current release line: 1.0.0-beta. Koin is the only supported dependency-injection adapter in this alpha, selected explicitly with beanEngine(KoinBeanEngine). The public DSL is kept adapter-neutral so a container SPI can land later without changing how your code is written.

Where to go next

Pick the door that matches what you need right now.

• New here?

  Start with the getting-started tutorial. Build and run your first Katalyst service end to end.

• Trying to do something specific?

  The how-to guides are task-focused recipes: configure YAML, define tables, schedule jobs, publish events, test your app.

• Looking up an API?

  The reference documents every module, the application DSL, the discovery interfaces, configuration keys, and each subsystem.

• Want the "why"?

  The explanation covers the bootstrap lifecycle, the interface-driven design, and the trade-offs behind Katalyst.

What you get

You depend on starters: each one bundles the Katalyst modules and external libraries (Ktor, Exposed, HikariCP, JDBC drivers, …) for a capability, so you never list those third-party dependencies yourself. A BOM keeps every version aligned.

Capability	Starter	Reference
Application bootstrap DSL	katalyst-starter-core	Application DSL
Annotation-free dependency injection	katalyst-starter-core	DI & auto-wiring
YAML configuration, profiles, env interpolation	katalyst-starter-core	Configuration
In-process transactional event bus	katalyst-starter-core	Events
Exposed + HikariCP persistence	katalyst-starter-persistence	Persistence
Transaction management with retry	katalyst-starter-persistence	Transactions
Database migrations	katalyst-starter-migrations	Migrations
Scheduler (cron / fixed delay / fixed rate / one-time)	katalyst-starter-scheduler	Scheduler
Routing, middleware, exception handlers, Netty engine	katalyst-starter-web	Ktor integration
WebSockets	katalyst-starter-websockets	Ktor integration
Pluggable server engines (Netty / Jetty / CIO)	katalyst-starter-web + engine module	Choose an engine
Testing helpers	katalyst-starter-test	Testing

See the module map for every starter, the underlying modules each one bundles, and their coordinates.