A Kotlin Multiplatform networking library — one codebase, every domain.

Kotlin Multiplatform lets you share application logic across servers, browsers, and phones. kuilt extends that to the parts of a connected app that are usually different on every platform:

WebSocket on a server, WebRTC in a browser, Network.framework on iPhone, Nearby on Android: four different APIs for the same idea. kuilt replaces them with a single interface — host a session, join a session, send a frame, watch who's connected. Swap the underlying transport without changing your application code.

When users on different devices edit shared state at the same time, something has to decide what wins. kuilt's replicated data structures converge automatically to the same result on every device — no custom merge logic, no "last save wins" bugs.

The CRDT types (LWWMap, ORSet, Rga, JsonCrdt, …) are plain serializable value objects. You can use them with any transport you already have — or without any network at all. Live propagation via Quilter is optional.

Collaborative and multiplayer apps need a reliable answer to "who goes next?" and "did that just happen?". kuilt's shared log — powered by Raft — gives every participant the same committed history, in the same order, even when connections drop and rejoin.

RaftTransport is an interface — you can run the Raft implementation over your own messaging layer (gRPC, a queue, anything) without using any kuilt fabric module.

When something goes wrong on a phone with no signal, the evidence is usually gone by the time anyone looks. kuilt records traces, metrics and logs on the device and reconciles them across devices once the network returns — nothing lost, nothing counted twice.

It's OpenTelemetry, so collectors and dashboards you already run read it unchanged. Tests and CI can also pull the logs off a live device by joining it as a peer, without the device ever talking to a server.

val loom = InMemoryLoom()                            // swap for any real fabric
val host  = loom.host(Pattern(sessionName = "alice"))
val guest = loom.join(InMemoryTag("bob"))

// Collect `incoming` exactly once per Seam; fan out with shareIn if you need to.
scope.launch { host.incoming.collect { println(it.payload.decodeToString()) } }
guest.broadcast("hello".encodeToByteArray())

→ Getting started — WebSocket hello world, then chat (replicated data) and tic-tac-toe (consensus and leadership) built on top.

// settings.gradle.kts
repositories { mavenCentral() }

Import the BOM once to align all module versions, then add individual modules without version numbers:

// build.gradle.kts
dependencies {
    implementation(platform("us.tractat.kuilt:kuilt-bom:0.7.3"))

    implementation("us.tractat.kuilt:kuilt-websocket")  // WebSocket fabric
    implementation("us.tractat.kuilt:kuilt-raft")       // Raft consensus
    implementation("us.tractat.kuilt:kuilt-crdt")       // CRDT zoo
    implementation("us.tractat.kuilt:kuilt-session")    // membership / room
}

Fabric and session modules re-export the kuilt-core contract, so you rarely list kuilt-core directly. The data modules are the exception: kuilt-crdt and kuilt-bolt are plain serializable value types that don't depend on the networking contract at all, so add kuilt-core yourself if you want Loom and Seam alongside them.

// build.gradle.kts — pick the modules you need, specifying versions explicitly
dependencies {
    implementation("us.tractat.kuilt:kuilt-core:0.7.3")
    implementation("us.tractat.kuilt:kuilt-websocket:0.7.3")
}

Replace 0.7.3 with the latest release.

Contract & core

Libraries

Fabrics

Test support

Observability

Playground — pre-1.0, outside the stability surface; API may change, not for production.

Most modules sit directly on kuilt-core, but the higher-level ones build on each other — kuilt-heddle layers over kuilt-raft and kuilt-quilter, and kuilt-game over kuilt-raft and kuilt-session. Gradle pulls in whatever a module needs; the BOM keeps every version aligned. The one rule that never bends is the direction: nothing points back into kuilt-core, which is what keeps the contract free of any one fabric's assumptions.

The contract is quilt-themed. Eight types carry the whole surface:

There is no client/server split. Every peer holds an identical Seam; a 2-peer WebSocket connection is the degenerate peers.size == 2 case of the same symmetric model.

The full documentation suite is published to GitHub Pages on every push to main:

• Guide — concepts, usage, fabrics, and the CRDT zoo, with every code example drawn from real, compiled test code.
• API reference — Dokka multi-module reference for every public symbol, with runnable @sample snippets.
• Observability — the offline-first OpenTelemetry exporter (kuilt-otel): record on any device, survive being offline, and deliver to your dashboard with no duplicates.
• Playground → Warp — the coordination-free distributed scheduler (kuilt-warp) and the research behind it.

The in-repo sources are docs/usage.md (open/join a WebSocket session, discover peers over mDNS, write + conformance-test your own fabric) and docs/architecture.md (the design and the rules the contract enforces).

source ~/.sdkman/bin/sdkman-init.sh && sdk use java 21.0.5-tem  # JDK 21, matches CI
./gradlew build       # build + test everything
./gradlew jvmTest     # fast inner loop