zio/zio-http

This system is a high-performance, cross-platform HTTP library for Scala that provides a type-safe endpoint DSL for building servers and clients. It features a comprehensive code generation engine capable of producing Scala code from OpenAPI, Protobuf/gRPC, and Smithy specifications. The library includes extensive tooling for testing, metrics, and CLI generation, alongside support for modern web patterns like WebSockets, SSE, and various authentication mechanisms.

17 changes.

The project underwent a major infrastructure overhaul, migrating the build system and core HTTP abstractions to ZIO 2.0 and zio-http 2.0. This period introduced significant new capabilities, including a testkit for mocking, a CLI generator, and a code generation engine for OpenAPI and Protobuf specifications. Comprehensive testing and benchmarking were added to validate these new features and ensure performance.

33 changes.

The project significantly restructured the JVM HTTP layer by introducing a comprehensive Netty integration, featuring modular server and client pipelines, optimized body handling, and advanced SSL support. Concurrently, it expanded platform compatibility by implementing a native JavaScript HTTP client using the Fetch API and added Scala 3-specific macro support for string interpolators. The period also saw the introduction of gRPC code generation tools and extensive test coverage for these new architectural components.

17 changes.

This period focused on enhancing developer tooling by adding AI agent onboarding features to the website and introducing a new Datastar SDK for reactive state management. It also expanded protocol support with STOMP integration, Smithy IDL code generation, and comprehensive authentication examples, alongside significant performance benchmarking and documentation modernization.

A new example project demonstrating real-time multi-client chat using ZIO, ZIO HTTP, and Datastar. The application provides a styled web interface for users to enter a username and send messages, with server-sent events pushing updates to the client. It includes the necessary Scala models (ChatMessage, MessageRequest), a ChatRoom service for managing state and subscriptions via ZIO Ref and Hub, and the server routes handling the HTML page, message history, and message submission.

zio-http-example-datastar-chat · high confidence

A new profiling environment is available in the \profiling\ directory, allowing users to profile the ZIO HTTP application using YourKit. This setup includes a Dockerfile that installs YourKit Java Profiler 2022.9 and exposes ports 8080 (application) and 10001 (profiler). Helper scripts (\build-docker-image.sh\ and \run-zio-http.sh\) automate building a Docker image with the benchmark server and running it, enabling remote connection from the YourKit desktop client for performance analysis.

profiling · high confidence

This location introduces a complete demonstration of JWT-based authentication using ZIO-HTTP. It includes an AuthenticationServer that serves a modern web UI for login and token management, implements a JWT middleware for protecting routes (public, user profile, and admin endpoints), and provides a Scala client example for obtaining and using bearer tokens. The example also sets up the build environment with sbt 1.13.0 and the sbt-native-packager plugin.

zio-http-example-jwt-bearer-token-auth · high confidence

The zio-http-metrics module now provides a one-stop API to expose Prometheus metrics over HTTP. By using \MetricsEndpoint.withMetrics\, users can automatically instrument their routes with request/response metrics (concurrent requests, total requests, and request duration) and append a \/metrics\ endpoint that serves data in Prometheus text format. The module also includes a dedicated \endpointRoute\ for custom instrumentation setups and a combined ZIO layer (\MetricsEndpoint.layers\) to configure the Prometheus publisher with a configurable polling interval.

zio-http-metrics · high confidence

The new zio-http-stomp module provides type-safe encoding and decoding for STOMP frames (versions 1.0, 1.1, and 1.2), including support for header escaping, transactions, and heartbeats. It integrates with ZIO HTTP by allowing STOMP frames to be transmitted over WebSocket binary frames and exposes an Endpoint API for streaming STOMP frames directly from HTTP routes.

zio-http-stomp · high confidence

The documentation build now includes a new utility object for handling source code snippets and a dedicated component for generating configuration reference tables from ZIO Config definitions. The ConfigReference module automatically renders configuration fields into a Markdown table and resolves an issue where repeated headings caused broken links in the documentation site by appending occurrence numbers to duplicate heading text. Additionally, a new utils.scala file provides helper functions to read source files and print code snippets with syntax highlighting and optional line numbers, supporting the generation of code examples in the docs.

zio-http-docs · high confidence

New example projects have been added to demonstrate basic, cookie-based, and digest authentication patterns. These include server implementations with in-memory user stores and middleware, corresponding client applications, and interactive HTML interfaces for testing the flows.

(repo-wide) · high confidence

Endpoints can now generate absolute URLs. On JavaScript, the new \urlAbsolute\ method constructs a URL using the current browser window's protocol and host, while the JVM platform provides the corresponding platform-specific trait stub to maintain API parity.

zio-http/js/src/main/scala/zio/http/endpoint, zio-http/jvm/src/main/scala/zio/http/endpoint · high confidence

A new code generator (ZIOHttpGRPCGen) has been added to the sbt-zio-http-grpc module. This tool processes protobuf specifications to generate Scala source files for ZIO HTTP gRPC services, including the necessary schema definitions for data types.

sbt-zio-http-grpc · high confidence

The zio-http-htmx module now includes a comprehensive set of htmx attributes (such as hx-get, hx-post, hx-boost, and various hx-on event handlers) via the new Attributes.scala file, making them available for use in HTML templates. This addition allows developers to easily integrate htmx functionality into their ZIO HTTP applications by providing type-safe access to these attributes.

zio-http-htmx · high confidence

A new \GenerateMediaTypes\ tool has been added to \zio-http-tools\ that fetches the latest MIME type definitions from the \jshttp/mime-db\ repository and automatically generates the \MediaTypes.scala\ source file. This ensures that the library's media type constants remain up-to-date with the standard database without requiring manual maintenance.

zio-http-tools · high confidence

Adds a new \HttpCliApp\ component in the \zio-http-cli\ module that automatically generates a command-line interface from a set of ZIO HTTP \Endpoint\ definitions. This feature allows users to create CLI tools that can invoke HTTP endpoints by parsing endpoint metadata (such as paths, query parameters, headers, and body schemas) into CLI options, supporting body input from files, URLs, or direct JSON text, and executing requests using a configurable HTTP client.

zio-http-cli/src/main · high confidence

This release adds the zio-http-datastar SDK, providing a comprehensive Scala API for building Datastar-driven applications. The SDK introduces a DSL for rendering Datastar-specific HTML attributes (such as data-bind, data-on, and data-class) with support for case modifiers and event modifiers. It includes a type-safe Signal system for managing reactive state, allowing signals to be read from HTTP requests via Schema and updated via Server-Sent Events. The package also provides utilities for generating Datastar events (PatchElements, PatchSignals, ExecuteScript), handling script execution with proper escaping, and creating complete HTML page templates with CDN-loaded Datastar scripts.

zio-http-datastar-sdk · high confidence

A new example application has been added to demonstrate JWT-based authentication with automatic refresh token management. The example includes a ZIO-HTTP server that issues short-lived access tokens and long-lived refresh tokens, along with endpoints for login, token refresh, logout, and protected resource access. It also provides a browser-based client (available as both a simple and a full-featured UI) that handles token storage, automatic refresh on 401 responses, and manual token management. The implementation uses in-memory stores for users and refresh tokens, supporting role-based access control for admin and user routes.

zio-http-example-jwt-bearer-refresh-token-auth · high confidence

The code generator now supports generating ZIO HTTP endpoints from Protobuf specifications, introducing a new \grpc\ generator that translates Protobuf services and methods into HTTP POST endpoints with gRPC media types. Additionally, the OpenAPI code generator now includes a \Config\ class that allows users to customize code generation behavior, specifically enabling the extraction of common fields into sealed trait super types, the generation of safe type aliases (Newtypes) for aliased primitives, and the normalization of field names with preservation of original casing via annotations.

zio-http-gen/src/main/scala/zio/http/gen/openapi · high confidence

The \zio-http-gen\ module now includes a new Scala code generation engine located in \zio/http/gen/scala\. This introduces a structured AST (\Code.scala\) representing generated Scala types (case classes, enums, objects) and endpoints, along with a renderer (\CodeGen.scala\) that outputs formatted Scala source files. The generator supports normalizing field names to valid Scala identifiers while preserving original names via \@fieldName\ annotations, handles schema derivation (including newtype aliases), and manages imports and formatting via Scalafmt.

zio-http-gen/src/main/scala/zio/http/gen/scala · high confidence

The zio-http-example module now includes a comprehensive set of new demonstration applications. These cover JWT-based Bearer authentication (AuthenticationServer/Client), Basic Authentication, and Cookie-based session management. It also adds detailed examples for configuring TLS and mutual TLS (mTLS) with various certificate authorities (self-signed, root-ca, intermediate-ca), alongside client-side features like connection pooling, response decompression, and curl logging. Additional examples demonstrate graceful shutdown, CORS configuration, Prometheus metrics integration, and the new Endpoint API with OpenAPI/Swagger generation.

zio-http-example · high confidence

The website now features a redesigned homepage with several new content sections: a tabbed code snippet showcase demonstrating ZIO HTTP patterns (servers, endpoints, middleware, clients, WebSockets), a key features overview, an ecosystem directory highlighting ZIO and related libraries, a users section for customer logos, and a promotion for the Zionomicon book. Additionally, a new 'Onboard your agent to ZIO HTTP' button has been added to the hero section and navbar, which copies a setup prompt to the clipboard to help coding agents like Claude, Codex, Cursor, and OpenCode get started with ZIO HTTP development.

website/src · high confidence

The zio-http-testkit module introduces dedicated components for testing HTTP applications without requiring a live server. TestServer allows tests to bind to a local port and define specific request-response behaviors or routes, enabling integration-style tests against a real HTTP stack. TestClient provides a mock driver that simulates server responses in-memory, allowing client-side code to be tested without network calls. Additionally, HttpTestAspect provides test aspects to control the application mode (dev, prod, preprod) during tests, and TestChannel facilitates WebSocket testing by managing event queues between client and server sides.

zio-http-testkit/src/main · high confidence

The repository has been initialized with a standard project structure, including an Apache 2.0 license, a generated README, and a security policy. Build tooling is configured with SBT options for increased memory, scalafmt 3.9.4 for code formatting, and scalafix rules for import organization. CI/CD is set up via Netlify for documentation and GitHub Actions, while legacy Travis CI configuration and outdated benchmark documentation have been removed.

(repo-wide) · high confidence

The library now provides Scala 3-specific implementations for its string interpolators, enabling compile-time validation and macro-based resolution for URL, Markdown, CSS, and JavaScript strings. This adds \url\, \md\, \css\, \selector\, and \js\ interpolators to the \template2\ and root packages for Scala 3 users, mirroring the existing Scala 2 functionality while leveraging Scala 3's \scala.quoted\ macros for improved type safety and error reporting during compilation.

zio-http/shared · high confidence

A new code generator has been added to the \zio-http-gen\ module that parses Smithy 2.0 IDL specifications and generates corresponding Scala code. This addition includes a full AST parser (\Smithy.scala\), text codecs for parsing (\SmithyCodecs.scala\), a configuration model (\SmithyConfig.scala\), a validation engine (\SmithyValidation.scala\), and the core generation logic (\SmithyEndpointGen.scala\) that produces zio-http Endpoint definitions, case classes, and sealed traits from Smithy models.

zio-http-gen/src/main/scala/zio/http/gen/smithy · high confidence

The website now includes configuration files to support its deployment and search capabilities, specifically adding a .nojekyll file, a robots.txt that excludes the search page from indexing, and a context7.json for LLM context. It also introduces a new start.md guide that provides step-by-step instructions for setting up AI coding agents (such as Claude Code, Codex, and Cursor) with ZIO HTTP skills and an MCP server, and adds a redirect rule to handle a duplicate examples path.

website/static · high confidence

The \zio-http\ module has removed its legacy HTTP domain model and core infrastructure, including the \Http\ effect type, \HttpApp\ constructors, and associated model classes such as \Request\, \Response\, \Status\, \Method\, \Path\, and \URL\. Additionally, core Netty integration layers—including the \ByteBuf\ wrapper, \AliasModule\ type aliases, and the \ChannelFactory\ and \ChannelFuture\ ZIO utilities—have been deleted, along with the WebSocket \Socket\ abstraction and its supporting types. This change eliminates the previous functional HTTP API and its underlying Netty bindings from this location.

zio-http · high confidence

The project's build system has been significantly restructured and upgraded. Sbt has been updated from version 1.4.7 to 1.13.0, and numerous plugins have been added or updated, including sbt-scalafix (0.9.26 to 0.14.9), sbt-scalafmt (2.4.2 to 2.6.2), sbt-jmh (0.4.0 to 0.4.8), and the introduction of sbt-github-actions (0.32.1), sbt-ci-release, sbt-shading, sbt-scoverage, and sbt-mima-plugin. New Scala source files in the \project/\ directory define centralized dependency management (Dependencies.scala), build helper settings (BuildHelper.scala), and specific CI workflows for JMH benchmarks (JmhBenchmarkWorkflow.scala), TekuEmpower-style benchmarks (BenchmarkWorkFlow.scala), and code coverage (ScoverageWorkFlow.scala). Additionally, binary compatibility checks are now configured via MimaSettings.scala, and Netty dependency shading is handled by Shading.scala.

project · high confidence

The zio-http Scala.js build now supports parsing integer and long values from URL path segments. A new platform-specific implementation for PathCodecPlatformSpecific provides JS-compatible versions of parseInt and parseLong, replacing JVM-specific dependencies (such as java.util.Objects) that previously prevented compilation or runtime execution on JavaScript targets. Users can now use numeric path parameters in their routes when running on Scala.js.

zio-http/js/src/main/scala/zio/http/codec · high confidence

The JavaScript HTTP client now includes a batched driver mode that fully materializes response bodies in memory before decoding, addressing issues with partial reads and single-consumption streams. This change introduces new internal body types (\FetchBodyBatched\, \FetchBodyInternal\) and a \FetchDriverBatched\ that eagerly fetches bytes, allowing safe repeated access to response data. Users can opt into this behavior via the \disableStreaming\ API, which is particularly useful for small to medium responses where streaming overhead or stream-replay limitations are problematic.

zio-http/js/src/main/scala/zio/http/internal · high confidence

The Scala.js HTTP client implementation has been updated to use the browser's native Fetch API via \FetchDriver\. This change introduces a new \ZClientPlatformSpecific\ module that wires the client configuration to the fetch driver, specifically adding support for an optional user-agent header controlled by the \addUserAgentHeader\ config flag. Other platform-specific server and handler features remain stubbed as unsupported on Scala.js.

zio-http/js/src/main/scala/zio/http · high confidence

The JVM module now provides platform-specific implementations for the HTTP layer, wiring Netty as the underlying driver for both the server and the client. Server startup is configured via \ServerPlatformSpecific\ layers (\live\ and \customized\) that compose with \NettyDriver\. The HTTP client (\ZClientPlatformSpecific\) offers new construction methods (\fromConfig\, \customized\, \live\, \configured\, \default\) that integrate with Netty and a DNS resolver, including optional user-agent header injection. Static file serving handlers (\HandlerPlatformSpecific\) now support serving resources from the classpath, including full Range request support for local files and limited support (no Range) for JAR resources, with automatic media type and charset detection. Additionally, \URLPlatformSpecific\ adds a utility to convert absolute ZIO HTTP URLs to \java.net.URL\ instances.

zio-http/jvm/src/main/scala/zio/http · high confidence

The JVM-specific implementation of path codec parsing now explicitly delegates to \java.lang.Integer.parseInt\ and \java.lang.Long.parseLong\ for segment parsing. This change ensures that the parsing logic on the JVM platform is consistent with the intended behavior, supporting the broader goal of making int and long segment parsing compatible across JavaScript and JVM targets.

zio-http/jvm/src/main/scala/zio/http/codec · medium confidence

The benchmark suite has been updated to align with the zio-http 2.0 and ZIO 2.0 API changes. This includes migrating from the legacy \Http\ type to \Handler\ and \Routes\, updating package names from \zhttp\ to \zio.http\, and adapting runtime execution to use the new \ZIO.scoped\ and \runtime.unsafe.run\ patterns. Several benchmarks were added or replaced to measure performance of the new \Client.batched\ API, cookie decoding, date header encoding, and content-type parsing, while older benchmarks using the deprecated \Http\ combinators were removed or refactored.

zio-http-benchmarks/src/main/scala/zhttp.benchmarks · high confidence

The JVM Netty integration has been restructured into a new set of core components that provide configurable channel types (NIO, Epoll, KQueue, and experimental IoUring) via \ChannelFactories\ and \EventLoopGroups\, alongside a new \AsyncBodyReader\ that caps pre-connect buffers to prevent out-of-memory errors during streaming. Response handling now includes a \CachedDateHeader\ for efficient date encoding, a \HybridContentLengthHandler\ to dynamically switch between aggregated and chunked writing based on content size, and improved \NettyBody\/\NettyBodyWriter\ logic that correctly handles streaming, file, and async bodies while respecting content-length constraints for compression.

zio-http/jvm/src/main/scala/zio/http/netty · high confidence

This change introduces a new \Conversions\ object in the Netty model layer to handle the translation between ZIO HTTP types and Netty primitives. Key additions include support for Brotli compression in \CompressionOptions\, allowing users to enable this compression algorithm alongside GZip and Deflate. The conversion logic for HTTP headers has been updated to correctly handle multi-valued headers (like Set-Cookie) by using \add\ instead of \set\, preserving duplicate headers as required by HTTP standards. Additionally, status code conversions now support custom reason phrases, and HTTP method conversions handle custom methods more robustly.

zio-http/jvm/src/main/scala/zio/http/netty/model · high confidence

The Netty server implementation has been restructured into distinct modules (NettyDriver, ServerChannelInitializer, ServerInboundHandler, etc.) to improve maintainability and performance. This change introduces support for JKS keystore/truststore configurations in SSL settings, allowing users to load certificates from Java KeyStore files. It also adds a HybridContentLengthHandler to better manage request streaming, preventing OutOfMemory errors by capping pre-connect buffers. Additionally, HEAD responses now correctly respect user-defined Content-Length headers, and the server avoids unnecessary context switching when handling requests, reducing latency.

zio-http/jvm/src/main/scala/zio/http/netty/server · high confidence

The Netty client implementation has been restructured to use dedicated handler classes for clearer request and response processing. A new ClientInboundHandler manages HTTP response reception and request sending, while ClientResponseStreamHandler handles streaming body reads and connection pool lifecycle (marking connections as reusable or invalid based on keep-alive status and timeouts). ClientFailureHandler centralizes error handling for the client pipeline. SSL configuration is now managed via a new ClientSSLConverter that supports various certificate sources (files, resources, bytes) and key passwords. The NettyClientDriver wires these handlers into the Netty pipeline for both HTTP and WebSocket requests, and the NettyConnectionPool now implements the Happy Eyeballs algorithm for faster connection attempts by trying all resolved IP addresses.

zio-http/jvm/src/main/scala/zio/http/netty/client · high confidence

The Netty socket implementation now maps additional configuration options from \WebSocketConfig\ to the underlying Netty \WebSocketClientProtocolConfig\ and \WebSocketServerProtocolConfig\. Users can now control settings such as handshake timeouts, force-close timeouts, subprotocols, close frame handling, and decoder-specific options (like max frame payload length and UTF-8 validation) when establishing WebSocket connections, ensuring these settings are correctly passed through to the Netty layer.

zio-http/jvm/src/main/scala/zio/http/netty/socket · high confidence

The documentation site has been modernized by upgrading to Docusaurus 3.10.1 and React 18, with styling now powered by Tailwind CSS. This update introduces a new visual identity, including a ZIO HTTP-specific favicon, navbar logo, and social media card, all generated from a master artwork. The site also adds structured data for better search engine visibility, LLM-friendly documentation files, and a reorganized sidebar with categorized examples and reference sections.

website · high confidence

Add ZIO HTTP endpoint benchmark suite; Added JMH benchmarks for form-to-query, route matching, and roundtrip performance; Added JavaScript-specific test suites for HTTP client, path codec, and regex parsing; Added ZIO HTTP testing example project with comprehensive test patterns; Added benchmarks for date and query parameter encoding; Added property-based tests for the HTTP CLI endpoint generator; Added protobuf definitions and code-generation tests for gRPC; Added roundtrip tests for Scala 3 union type endpoints; Added security regression tests for exception handling, size limits, static file serving, and authentication; Added test coverage for HTTP header parsing and rendering; Added test coverage for Netty HTTP internals; Added test coverage for OpenAPI generation and Swagger UI integration; Added test coverage for body schema operations, client SSL, and streaming; Added test coverage for the HTTP codec subsystem; Added test model definitions for OpenAPI code generation; Added test resources for client SSL certificates and local HTTPS server; Added test resources for mutual TLS JKS keystores and truststores; Added test suite for zio-http-testkit; Added test suites for authentication, CORS, metrics, request logging, and web middleware; Added tests for Netty connection pool and request encoding; Added tests for Netty header and status code conversions; Added tests for Netty server event loop group configuration and shutdown behavior; Added tests for field normalization and OpenAPI code generation; Added tests for gRPC content codec encoding and decoding; Added tests for gRPC endpoint code generation; Added tests for the Smithy IDL code generator; Added tests for the ZIO HTTP template DSL; Expanded test coverage for ZIO HTTP Endpoint API; Expanded test resources for OpenAPI code generation.

Added new example projects for Basic, Cookie, Digest, JWT Bearer, Oauth Bearer, Opaque Bearer, and WebAuthn authentication, each configured with ZIO 2.1.24, ZIO HTTP 3.5.1, and Docker packaging. Updated the website dependencies to Docusaurus 3.10.1, React 18.3.1, and added plugins for copy-page-button and LLMs. Added a new profiling build configuration and a documentation package manifest.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 62 → 60 (-2.1)
• Rubric changed (rubric-2026.09.8 → rubric-2026.09.16) — scores are not directly comparable.

• Code Health 83 → 83 (+0.0)
• Architecture 96 → 63 (-33.0)
• Maturity 65 → 65 (-0.1)
• Readiness 73 → 63 (-9.1)
• Security 65 → 66 (+1.8)
• Accessibility 54 → 54 (+0.0)
• Performance 100 (new)

• Documentation: written for insiders (docs/reference/index.md)
• Duplicated block (21–24 lines × 3) (zio-http/shared/src/main/scala/zio/http/codec/HttpCodec.scala)
• Off-boarding risk: anonymized user #1

• Documentation: no usage examples (docs/index.md)
• Duplicated block (21–24 lines × 3) (zio-http/shared/src/main/scala/zio/http/codec/HttpCodec.scala)
• No ADRs found
• Off-boarding risk: anonymized user #1
• Outdated: com.lihaoyi:unroll-plugin_2.13
• Outdated: com.softwaremill.sttp.tapir:tapir-akka-http-server_2.13
• Outdated: com.yubico:webauthn-server-attestation
• Outdated: com.yubico:webauthn-server-core
• Outdated: dev.zio:zio-config_2.13
• Outdated: dev.zio:zio-http_2.13
• Outdated: dev.zio:zio-interop-cats_2.13
• Outdated: dev.zio:zio-metrics-connectors-prometheus_2.13
• Outdated: dev.zio:zio-metrics-connectors_2.13
• Outdated: dev.zio:zio_2.13
• Projects may be oversized for their cohesion

• 11 commits — 9 feature/other, 2 fixes

• (root) — 3 commits
• zio-http/jvm — 2 commits
• profiling/project — 1 commit
• project/Dependencies.scala — 1 commit
• project/plugins.sbt — 1 commit
• website/static — 1 commit
• website/yarn.lock — 1 commit
• zio-http/shared — 1 commit

• fix: Fix #4133: Add matching hashCode override to OpenAPI.Parameter (#4169)
• fix: Fix Routes.provide wiping per-request Scope (fixes #4318) (#4320)
• change: Add JVM system trust-store support to ClientSSLConfig (#4315)
• change: Update parsers to 4.17.4 (#4308)
• change: Update protobuf-java to 4.36.2 (#4316)
• change: Update sbt-mima-plugin to 1.2.1 (#4317)
• change: Update sbt-scalafix to 0.14.9 (#4312)
• change: Update slf4j-api, slf4j-simple to 2.0.20 (#4319)
• change: Update tapir-http4s-server, ... to 1.13.32 (#4323)
• change: chore(deps): bump image-size from 2.0.2 to 2.0.4 in /website (#4321)
• change: docs(website): add MCP server setup to start.md (#4322)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

zio/zio-http was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.