A suite of Kotlin libraries that handle the hard parts for you. Dependency injection, serialization, reactive state, SPAs, database access — all designed to work together, all type-safe, all without the ceremony.

Documentation: peekandpoke.io

Lightweight DI container built around per-request scoping. Fresh containers per unit of work, validated dependency graphs. No annotations, no reflection, no runtime surprises.

val blueprint = kontainer {
    singleton(UserService::class)
    dynamic(RequestScope::class)
}

val kontainer = blueprint.create()
val service = kontainer.get(UserService::class)

Kotlin-first serialization that understands nullable types, default values, and sealed classes. No annotations needed. Two-pass error handling gives you speed when it works and precision when it doesn't.

val codec = Codec.default

val map = codec.slumber(User("Alice", 30))   // serialize
val user = codec.awake<User>(map)             // deserialize

Lightweight reactive streams with always-has-a-value semantics. Composable operators, lazy subscriptions, automatic cleanup. Powers Kraft's reactive state management.

val source = StreamSource(0)
val doubled = source.map { it * 2 }

doubled.subscribe { println(it) }
source(5)  // prints: 10

Write AQL queries in Kotlin with full type safety. KSP generates compile-time checked property accessors. Repository pattern with CRUD, hooks, and index management.

val adults = repo.findList {
    FOR(repo) { person ->
        FILTER(person.age GTE 18)
        SORT(person.name.ASC)
        RETURN(person)
    }
}

Component-based SPA framework using Preact under the hood. Type-safe HTML DSL, reactive state, routing, forms, SemanticUI integration, and 12 addon wrappers.

class Counter(ctx: NoProps) : PureComponent(ctx) {
    private var count by value(0)

    override fun VDom.render() {
        ui.button {
            onClick { count++ }
            +"Clicked $count times"
        }
    }
}

Example projects: Hello World | Router Demo | Remote API

KSP-generated mutable wrappers for immutable data classes. Inspired by immer.js. Nested mutations, automatic change propagation, dirty tracking — zero boilerplate.

// Without Mutator: nested copy() hell
val updated = company.copy(
    ceo = company.ceo.copy(
        address = company.ceo.address.copy(city = "Amsterdam")
    )
)

// With Mutator: just mutate it
val updated = company.mutate {
    ceo.address.city = "Amsterdam"
}

• Funktor — Full-stack Kotlin framework on Ktor (auth, REST, clustering, static web)

All libraries are published on Maven Central:

dependencies {
    implementation("io.peekandpoke.ultra:mutator-core:0.107.0")
    ksp("io.peekandpoke.ultra:mutator-ksp:0.107.0")
    implementation("io.peekandpoke.ultra:kontainer:0.107.0")
    implementation("io.peekandpoke.ultra:slumber:0.107.0")
    implementation("io.peekandpoke.ultra:streams:0.107.0")
    implementation("io.peekandpoke.ultra:karango-core:0.107.0")
    implementation("io.peekandpoke.kraft:core:0.107.0")
}

This project provides machine-readable documentation:

• llms.txt — index with links to per-library docs
• llms-full.txt — complete documentation in one file

Apache License 2.0