This is a Kotlin Multiplatform line-by-line transliteration port of tiny-http/tiny-http.

Original Project: This port is based on tiny-http/tiny-http. All design credit and project intent belong to the upstream authors; this repository is a faithful port to Kotlin Multiplatform with no behavioural changes intended.

This is an in-progress port. The goal is feature parity with the upstream Rust crate while providing a native Kotlin Multiplatform API. Every Kotlin file carries a // port-lint: source <path> header naming its upstream Rust counterpart so the AST-distance tool can track provenance.

The text below is reproduced and lightly edited from https://github.com/tiny-http/tiny-http. It is the upstream project's own description and remains under the upstream authors' authorship; links have been rewritten to absolute upstream URLs so they continue to resolve from this repository.

Documentation

Tiny but strong HTTP server in Rust. Its main objectives are to be 100% compliant with the HTTP standard and to provide an easy way to create an HTTP server.

What does tiny-http handle?

• Accepting and managing connections to the clients
• Parsing requests
• Requests pipelining
• HTTPS (using either OpenSSL, Rustls or native-tls)
• Transfer-Encoding and Content-Encoding
• Turning user input (eg. POST input) into a contiguous UTF-8 string (not implemented yet)
• Ranges (not implemented yet)
• Connection: upgrade (used by websockets)

Tiny-http handles everything that is related to client connections and data transfers and encoding.

Everything else (parsing the values of the headers, multipart data, routing, etags, cache-control, HTML templates, etc.) must be handled by your code. If you want to create a website in Rust, I strongly recommend using a framework instead of this library.

Add this to the Cargo.toml file of your project:

[dependencies]
tiny_http = "0.11"

use tiny_http::{Server, Response};

let server = Server::http("0.0.0.0:8000").unwrap();

for request in server.incoming_requests() {
    println!("received request! method: {:?}, url: {:?}, headers: {:?}",
        request.method(),
        request.url(),
        request.headers()
    );

    let response = Response::from_string("hello world");
    request.respond(response);
}

Tiny-http was designed with speed in mind:

• Each client connection will be dispatched to a thread pool. Each thread will handle one client. If there is no thread available when a client connects, a new one is created. Threads that are idle for a long time (currently 5 seconds) will automatically die.
• If multiple requests from the same client are being pipelined (ie. multiple requests are sent without waiting for the answer), tiny-http will read them all at once and they will all be available via server.recv(). Tiny-http will automatically rearrange the responses so that they are sent in the right order.
• One exception to the previous statement exists when a request has a large body (currently > 1kB), in which case the request handler will read the body directly from the stream and tiny-http will wait for it to be read before processing the next request. Tiny-http will never wait for a request to be answered to read the next one.
• When a client connection has sent its last request (by sending Connection: close header), the thread will immediately stop reading from this client and can be reclaimed, even when the request has not yet been answered. The reading part of the socket will also be immediately closed.
• Decoding the client's request is done lazily. If you don't read the request's body, it will not be decoded.

Examples of tiny-http in use:

• heroku-tiny-http-hello-world - A simple web application demonstrating how to deploy tiny-http to Heroku
• crate-deps - A web service that generates images of dependency graphs for crates hosted on crates.io
• rouille - Web framework built on tiny-http

This project is licensed under either of

• Apache License, Version 2.0, (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
• MIT license (LICENSE-MIT or http://opensource.org/licenses/MIT)

at your option.

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in tiny-http by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

dependencies {
    implementation("io.github.kotlinmania:tiny-http-kotlin:0.1.3")
}

./gradlew build
./gradlew test

• macOS arm64
• Linux x64
• Windows mingw-x64
• iOS arm64 / simulator-arm64 (Swift export + XCFramework)
• JS (browser + Node.js)
• Wasm-JS (browser + Node.js)
• Android (API 24+)

See AGENTS.md and CLAUDE.md for translator discipline, port-lint header convention, and Rust → Kotlin idiom mapping.

This Kotlin port is distributed under the same MIT license as the upstream tiny-http/tiny-http. See LICENSE (and any sibling LICENSE-* / NOTICE files mirrored from upstream) for the full text.

Original work copyrighted by the tiny-http authors.
Kotlin port: Copyright (c) 2026 Sydney Renee and The Solace Project.

Thanks to the tiny-http/tiny-http maintainers and contributors for the original Rust implementation. This port reproduces their work in Kotlin Multiplatform; bug reports about upstream design or behavior should go to the upstream repository.