Expand description

An extensible and efficient forward-thinking web server for the future.

Kvarn is a rethought web server tailored for the current needs from web application developers.

It handles several things for you, including

  • Content-Type
  • Compression of body
  • Correct and performant HTTP/1 and HTTP/2
  • Common API across HTTP/1 and HTTP/2
  • Easy integration with HTTP/2 push promises
  • Five types of extensions, all backed with intuitive macros
  • Optional encryption with rustls
  • Several checks for illegal requests
  • cache-control and kvarn-cache-control header limits server cache lifetimes

Getting started

To get started, configure a RunConfig. See the example at RunConfig::execute on how to get a simple web server running.

A battle-tested reference implementation can be found at GitHub. It powers my two websites with minimal resource requirements.

Future plans

See the README @ GitHub and kvarn.org.


pub use error::default as default_error;
pub use error::default_response as default_error_response;
pub use extensions::Extensions;
pub use extensions::Id;
pub use read::file as read_file;
pub use read::file_cached as read_file_cached;


Abstractions for the application layer, providing a common interface for all HTTP versions supported.

Compress and cache.

CORS implementation for Kvarn.

CSP implementation for Kvarn.

Control the Kvarn server from the outside.

Encryption for incoming and outgoing traffic, implemented through streams.

Utility functions to generate error responses.

Here, all extensions code is housed.

Handling of multiple Hosts on one instance of Kvarn.

Limits traffic from a IP address to partially mitigate attacks.

The Kvarn Prelude

Utilities for reading files with or without a FileCache.

Graceful shutdown for Kvarn.

Vary header handling in Kvarn.


Easy and fast WebSockets for Kvarn.


Create a pinned future, compatible with crate::RetFut.

The ultimate extension-creation macro.

Construct a Package extension like you write closures.

Create a Plugin.

Construct a Post extension like you write closures.

Construct a Prepare extension like you write closures.

Construct a Present extension like you write closures.

Construct a Prime extension like you write closures.

Creates a RunConfig from PortDescriptors. This allows you to configure the RunConfig and then RunConfig::execute the server.


The returned data from handle_cache.

A Response returned by handle_request().

Describes port, certificate, and host data for a single port to bind.

Configuration for Self::execute. This mainly consists of an array of PortDescriptors.


Which version of the Internet Protocol to bind to.

How to send data to the client.


The Kvarn server header. Can also be used for identifying the client when using Kvarn as a reverse-proxy.


Will handle a single request, check the cache, process if needed, and caches it. This is where the response is sent.

Handles a single connection. This includes encrypting it, extracting the HTTP header information, optionally (HTTP/2 & HTTP/3) decompressing them, and passing the request to handle_cache(). It will also recognize which host should handle the connection.

Handles a single request and returns response with cache and compress preference.

Type Definitions

The Request used within Kvarn.