Tez

Most "I built a web server" projects either wrap a framework that does all the real work, or stop at a toy that handles one request and exits. Tez sets a harder bar: implement the full HTTP/1.1 request lifecycle — parse, route, respond — by hand, with persistent connections, a real concurrency model and caching, while still standing on a production-grade async I/O foundation rather than reinventing the event loop.

Tez delegates only the socket and event layer to Boost.Asio (io_context, tcp::acceptor, async_accept, async signal handling) and writes everything above it by hand. Requests are parsed manually with Content-Length body handling; routing goes through a JSON-configured table (nlohmann/json) or a static file server. The HTTP/1.1 response — Date, Server, Connection, Keep-Alive, Content-Length — is assembled by hand. Concurrency runs on a hand-rolled fixed-size thread pool (std::vector<std::thread> + std::queue guarded by a mutex/condition_variable, a templated enqueue() returning std::future via std::packaged_task), and a dual LRU layer (100-entry response cache, 50-entry file cache, 60s TTL) sits behind mutex guards. GoogleTest covers the router, middleware, file server and response builder.

The load-bearing decision is the boundary: build on Boost.Asio for sockets and events instead of hand-coding an epoll/kqueue loop, while hand-writing HTTP parsing, routing, response building, the thread pool and caching. That keeps the educational surface where it's defensible — protocol and concurrency mechanics I can explain line by line — without sinking the budget into an event loop Boost already does correctly. A second deliberate choice is error_code over exceptions on the hot path, with RAII for cleanup: the ThreadPool destructor joins every worker, sockets are make_shared and lifetime-managed, so the fast path stays allocation- and exception-light.

Tez is a public, MIT-licensed repo with a tagged v1.0.0 release and a green CI/CD pipeline. It implements GET/POST/PUT/DELETE, keep-alive (timeout 5s, max 1000 requests/connection), static serving with path-traversal protection via std::filesystem::weakly_canonical, and enforced limits (10 MB body, 8 KB header). On measured performance the honest scope is a localhost smoke test: the committed ApacheBench files ran only 100 requests at concurrency 10 and show ~10,897 req/s on the cached GET route with sub-millisecond mean latency — but at that scale every percentile reports 1 ms, so these are smoke-test figures, not sustained-load numbers, and are presented as such.