Most frameworks bury HTTP under annotations, reflection and a container. http4k throws all of that out and starts from one radical idea. Every one of the 200+ modules is built on it, and nothing sneaks in behind your back.
This is the part other HTTP libraries miss. The same single type - (Request) -> Response - models both sides of the wire. Your server is an HttpHandler. Your HTTP client is also an HttpHandler. So a real remote call and an in-memory fake are interchangeable - a superpower that falls straight out of the simplicity.
// a server takes a request, returns a response val server: HttpHandler = { req -> Response(OK).body("pong") } server(Request(GET, "/ping"))
// a client has the EXACT same type val client: HttpHandler = JavaHttpClient() // so calls are identical - swap one for // the other with zero ceremony client(Request(GET, "http://.../ping"))
The idea traces to the "Your Server as a Function" paper from Twitter - the observation that every system boundary can be modelled as a function from request to response. We took that generic concept and refined it specifically for HTTP.
Then we extended the same model outward - WebSockets, Server-Sent Events, typesafe message handling via Lenses, function-based API clients - proving most things compose. The core idea never changed: simplicity.
// server AND client... typealias HttpHandler = (Request) -> Response // ...and everything that wraps either. typealias Filter = (HttpHandler) -> HttpHandler // that's it. that's the toolkit.
http4k was built from scratch to fully leverage Kotlin, against a non-negotiable set of principles. Every one of these is still true today.
Built on simple functional concepts, embracing immutability throughout.
The same "Server as a Function" model for both server and client.
No reflection. No annotations. No bytecode surprises. What you read is what runs.
Minimal dependencies - beyond the Kotlin StdLib, http4k-core has exactly zero.
Testable outside any HTTP container, with no custom infrastructure needed.
Ultra-quick start/stop times - ideal for serverless and rapid test cycles.
Typesafe HTTP message construction and deconstruction via Lenses.
Contract breaches are dealt with automatically, removing reams of boilerplate.
Typed routes generate the OpenAPI spec and JSON Schema, so docs never drift from what runs.
We're not precious about it. http4k distilled decades of using server-side libraries, and we pilfered the best parts shamelessly - then made them play together, the Kotlin way. Credit where it's due.
http4k's Scala-based ancestor. Everyone agreed it was too complex - so we threw it out and started again in Kotlin.
When both your server and your clients are the same kind of function, the hard things get easy - and some things other HTTP libraries simply can't do become trivial.
Wire entire suites of services together without HTTP, or spin them up in containers with a single line. No custom infrastructure required.
Because a client is just a function, a Fake server for any HTTP contract is trivial. With CDC suites, you can end-to-end test microservices outside-in, GOOS-style.
"What if this dependency takes >5s, every time?" Easy to model - and impossible to answer if you fake things inside the HTTP boundary.
Dig into the core concepts, or skip straight to your first running server.
