Skip to content
CAI
Software that uses CAICheck a score

zio/zio-http

47.7

Weak · 26 October 2026

71k

lines of production code

Scala

with JavaScript

4

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

ZIO HTTP is a high-performance, type-safe HTTP server and client library for Scala, built on the ZIO effect system and Netty. It provides a modern Endpoint API for defining routes with schema-based codecs, supporting features like authentication, WebSockets, gRPC, and SSE. The system includes extensive tooling for code generation from OpenAPI, Smithy, and Protobuf specifications, as well as utilities for metrics, testing, and HTML templating.

How it got here

2021–2024 — ZIO HTTP 2.0 migration and code generation

63 changes.

This period focused on migrating the codebase to ZIO HTTP 2.0 and ZIO 2.0, replacing the legacy HTTP domain with a new schema-driven codec API and refactoring the underlying Netty integration for better performance. The team significantly expanded developer tooling by introducing modules for OpenAPI and gRPC code generation, CLI client creation, and comprehensive test utilities. Extensive test coverage was added to validate the new architecture, platform-specific implementations, and security features.

2025–2026 — Developer experience and ecosystem expansion

21 changes.

This period focused on enhancing the developer experience through a comprehensive website overhaul, AI agent onboarding tools, and extensive new example applications for authentication and testing. It also expanded the library's ecosystem by introducing new modules for STOMP, Datastar, and Smithy code generation, alongside a new typed templating API and Prometheus metrics support.

Features

Add Datastar real-time chat example project

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

Add Docker-based profiling setup with YourKit integration

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

Add JWT Bearer Token Authentication example

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

Add Prometheus metrics endpoint for HTTP servers

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

Add STOMP protocol support module

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

Add ZIO Config reference generation and documentation utilities

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

Add platform-specific URL generation for endpoints

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

Added ZIO HTTP gRPC code generator

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

Added gRPC content codec support via Protobuf

A new GRPC object has been introduced in the zio-http endpoint module to provide implicit HttpContentCodec support for gRPC. This change enables automatic serialization and deserialization of types using Protobuf codecs when the 'application/grpc' media type is used, allowing users to handle gRPC payloads seamlessly within the HTTP endpoint framework.

zio-http/shared/src/main/scala/zio/http/endpoint/grpc · high confidence

Added gRPC endpoint code generation from Protobuf specifications

The code generator now supports creating ZIO HTTP endpoints directly from Protobuf service definitions. By processing a Protobuf file, the system generates Scala code that maps each service method to a POST endpoint with the path pattern /{service}/{method}, correctly handling client and server streaming flags, and setting the content type to application/grpc.

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

Compile-time validated CSS and JavaScript string interpolators

The template2 package now includes \css\, \selector\, and \js\ string interpolators that perform basic syntax validation at compile time. By importing the \CssInterpolator\ and \JsInterpolator\ traits, developers can write inline CSS, CSS selectors, and JavaScript code directly in their templates; the compiler will flag invalid syntax for static strings, helping catch errors early. This feature is implemented with Scala 2 macros and Scala 3 inline macros to support both language versions.

zio-http/shared/src/main/scala-2/zio/http/template2, zio-http/shared/src/main/scala-3/zio/http/template2 · high confidence

Internal codec construction and deconstruction logic added

A new internal \Mechanic\ object has been introduced in the \zio.http.codec.internal\ package to handle the construction and deconstruction of HTTP codec inputs. This component provides \makeConstructor\ and \makeDeconstructor\ methods that recursively process \HttpCodec\ structures (including combined atoms, transforms, and annotations) to generate functions for building and extracting data from codec inputs, enabling the framework to correctly map HTTP requests and responses to typed Scala values.

zio-http/shared/src/main/scala/zio/http/codec/internal · high confidence

Introduce template2 API with typed CSS/JS and HTML element definitions

The \zio.http.template2\ package now provides a new templating foundation, introducing \Css\ and \Js\ wrapper types for safer styling and scripting, alongside comprehensive \HtmlElements\ and \HtmlAttributes\ traits that expose standard HTML tags and attributes. The package object wires these together with implicit conversions, allowing users to import \zio.http.template2.\_\ to build DOM structures using typed modifiers and interpolators.

zio-http/shared/src/main/scala/zio/http/template2 · high confidence

Introduce zio-http-datastar SDK for server-side Datastar integration

This release adds the zio-http-datastar SDK, providing a complete integration with the Datastar framework. It introduces a new \Datastar\ type backed by a \Queue\[ServerSentEvent\[String\]\]\ for managing SSE streams, and a \DatastarPackageBase\ trait that exposes high-level utilities such as \datastarScript\ for loading the Datastar library from a CDN and \mainPage\ for generating full HTML templates. The SDK includes comprehensive support for Datastar attributes (like \dataBind\, \dataOn\, \dataSignals\) with case-modifier handling, and defines codecs for encoding \DatastarEvent\ types (PatchElements, PatchSignals, ExecuteScript) into HTTP responses. It also provides Endpoint integration, allowing Datastar events to be returned directly from ZIO HTTP endpoints, along with extensive test coverage for attribute rendering, event encoding, and CDN script generation.

zio-http-datastar-sdk · high confidence

New CLI generation from ZIO HTTP Endpoints

The CLI module now automatically generates command-line interfaces from ZIO HTTP \Endpoint\ definitions. By introducing \CliEndpoint\, \CliRequest\, and \HttpCommand\, the system extracts HTTP method, URL paths, query parameters, headers, and body schemas from an endpoint and maps them to CLI options. This allows users to define their API contract once in code and immediately get a functional CLI tool that supports sending requests with bodies from files, URLs, or direct JSON input, without writing manual CLI parsing logic.

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

New Datastar SDK and CLI client modules

This release introduces the \zio-http-datastar-sdk\ module, providing a comprehensive Scala API for the Datastar framework including signal management, DOM attribute helpers, and Server-Sent Event generation, alongside a new \zio-http-cli\ module that allows generating command-line interface clients directly from ZIO HTTP Endpoint definitions.

repository · high confidence

New HTML template DSL and utility components

This change introduces a new HTML templating API within the \zio.http.template\ package. It provides a \Template\ object containing a \container\ helper that generates a styled HTML page with a monospace font and centered layout, along with supporting type classes (\IsAttributeValue\) to handle implicit conversions for HTML attribute values such as strings, lists of strings, and key-value pairs.

zio-http/shared/src/main/scala/zio/http/template · high confidence

New HttpGen utility for generating HTTP files from Endpoint definitions

A new \HttpGen\ object has been added to the \zio.http.endpoint.http\ package, providing the ability to generate \HttpFile\ and \HttpEndpoint\ structures directly from \Endpoint\ definitions. This utility processes endpoint inputs to extract path, query, header, and body variables, converting ZIO Schema types into JSON Schema representations for body content and generating appropriate type hints for variables. It supports configuration via \CodecConfig\ and handles the mapping of endpoint metadata, such as documentation, into the generated HTTP structures.

zio-http/shared/src/main/scala/zio/http/endpoint/http · high confidence

New JWT Bearer Authentication Example with Refresh Tokens

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

New Scala code generation infrastructure for ZIO HTTP endpoints

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

New authentication demonstration applications

Added three new example applications—Basic Auth, Cookie Auth, and Digest Auth—each providing a Scala server and client implementation alongside HTML-based web clients. The Basic Auth example demonstrates header-based authentication with password hashing and role-based access control. The Cookie Auth example implements session-based authentication using in-memory session management and HTTP cookies. The Digest Auth example showcases RFC 2617 compliant digest authentication with nonce handling and multiple quality-of-protection options. All examples are configured to use sbt 1.13.0 and include the sbt-native-packager plugin for building distributable packages.

(repo-wide) · high confidence

New authentication, TLS, and client examples added to zio-http-example

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

New code generation configuration options for OpenAPI schema handling

The OpenAPI code generator now exposes a \Config\ class that allows users to control how schemas are translated into Scala types. Users can enable \commonFieldsOnSuperType\ to extract shared fields from \allOf\ expressions into abstract fields on sealed traits, set \generateSafeTypeAliases\ to preserve primitive type aliases as \zio.prelude.Newtype\ definitions instead of resolving them immediately, and configure \fieldNamesNormalization\ to automatically convert unconventional casing (like snake\_case) to camelCase while preserving original names via annotations. Additionally, a \stringFormatTypes\ map is available to customize how specific string formats are handled.

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

New homepage sections and AI agent onboarding button

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

New internal HTTP architecture and developer tooling

This release introduces a foundational restructure of the HTTP server internals, adding core abstractions such as \ProtocolStack\ for layered request/response transformation, \HandlerAspect\ for middleware context, and \CanServe\ to enforce that routes handle errors before serving. It also adds a \RoutesOverview\ component that provides a 404 page in dev mode listing all current routes with parameter inputs, and introduces \RequestStore\ for per-request context storage.

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

New internal encoding, header, and query parameter APIs

The library introduces a suite of new internal utilities and traits to handle HTTP data more efficiently. This includes dedicated encoders for cookies (CookieEncoding) and dates (DateEncoding, replacing the previous Netty-based RFC 1123 implementation), as well as HTML output encoding (OutputEncoder) for security. A new schema-based system for headers and query parameters (HeaderGetters, QueryGetters, HeaderModifier, QueryModifier) allows users to extract and modify these values using ZIO Schema types. Additionally, performance is improved through the addition of object pools for ByteArrays and StringBuilders (ByteArrayOutputStreamPool, StringBuilderPool) and optimized CharSequence comparison utilities.

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

New testkit module with TestServer and dev-mode test aspects

A new testkit module has been introduced, providing a \TestServer\ that allows tests to define specific request-response mappings or add custom routes against a real local server instance, and an \HttpTestAspect\ object that offers test aspects (\devMode\, \prodMode\, \preprodMode\) to control the application's runtime mode during testing.

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

Repository initialization and tooling configuration

The repository has been initialized with a standard project structure, including an Apache 2.0 license, a generated README, and a security policy for responsible vulnerability disclosure. Build and development workflows are configured via SBT (with specific JVM memory settings in .sbtopts), Scalafmt 3.9.4 for code formatting, and Scalafix for import organization. CI/CD is set up using GitHub Actions and Netlify for documentation hosting, while Renovate is present but disabled. Legacy Travis CI configuration and outdated benchmark documentation have been removed.

(repo-wide) · high confidence

Scala 3-specific compiler macros and inline utilities

This change introduces Scala 3 version-specific implementations for the ZIO HTTP library, adding compile-time capabilities that are not available in Scala 2. It provides inline URL and Markdown interpolators (via \UrlInterpolator\ and \MdInterpolator\) that resolve string patterns at compile time, and implements \HandlerVersionSpecific\ and \RoutesCompanionVersionSpecific\ to allow \HandlerAspect\ context to be provided via environment rather than function parameters, leveraging Scala 3's inline and transparent features for better type safety and performance.

zio-http/shared/src/main/scala-3/zio/http · high confidence

Smithy IDL code generator added to zio-http-gen

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

Support for union types in endpoint output definitions

The Scala 3 endpoint API now allows defining responses that return a union of types (e.g., \Either\[A, B\]\). This is achieved through new extension methods on the \Endpoint\ class, specifically \orOut\ and \orOutError\, which use compile-time transparent inlines and \Alternator\ to combine multiple output codecs or error schemas into a single endpoint definition. Users can now specify alternative response structures directly in their endpoint routes without manual decoding logic.

zio-http/shared/src/main/scala-3/zio/http/endpoint · high confidence

Removals

Removal of legacy HTTP domain and core abstractions

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

Behavioural changes

Build infrastructure overhaul and CI benchmarking integration

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

Deprecation of EndpointLocator

The \EndpointLocator\ trait and its companion object methods (such as \fromURL\) are now deprecated as of version 3.6.0 and will be removed in a future release. Users should migrate to using URLs directly to create an \EndpointExecutor\ instead of relying on the locator abstraction for endpoint resolution.

zio-http/shared/src/main/scala/zio/http/endpoint · high confidence

Enable integer and long path segment parsing on Scala.js

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

Htmx attributes are now importable via package object

The \zio-http-htmx\ module now exposes Htmx attributes (such as \hxGetAttr\) directly through the \zio.http.htmx\ package object, allowing users to import and use them without fully qualifying their names. This change simplifies the syntax for adding Htmx attributes to HTML templates, as demonstrated by the new test verifying that \hxGetAttr\ correctly renders the \hx-get\ attribute on a button element.

zio-http-htmx · high confidence

JS HTTP client now uses FetchDriver with configurable user-agent header

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

JVM-specific HTTP server, client, and handler implementations

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

JVM-specific integer and long parsing implementation for path codecs

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

Migrate benchmarks to zio-http 2.0 API and ZIO 2.0 runtime

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

New Netty model conversion utilities and brotli compression support

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

New schema-based HTTP codec API

The \zio.http.codec\ package has been restructured to introduce a new, schema-driven API for defining HTTP endpoints. This change adds foundational type classes like \Alternator\ and \Combiner\ to handle type composition, and introduces \CodecConfig\ to allow global or aspect-based configuration of serialization behaviors (such as handling empty collections or nulls). The previous \TextCodec\-based methods for headers and queries are now deprecated in favor of new \headerAs\ and \query\ methods that derive codecs directly from \zio.schema.Schema\ instances, enabling more robust and type-safe endpoint definitions.

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

Refactor Netty server into modular components with improved SSL and streaming support

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

Refactored Netty client pipeline with dedicated handlers and SSL conversion

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

Refactored Netty runtime and channel infrastructure

The Netty integration layer has been restructured to improve performance and reliability. A new \CachedDateHeader\ component replaces the previous date encoding implementation, using a background thread to cache the HTTP Date header value for faster response generation. Channel and EventLoop lifecycle management has been consolidated into new \ChannelFactories\ and \EventLoopGroups\ modules, providing explicit support for NIO, Epoll, KQueue, and the experimental IoUring transports. The \NettyRuntime\ has been updated to use \fork\ instead of \runOrFork\ for executing ZIO effects, and the \NettyBodyWriter\ now handles streaming and file bodies with improved logic for content-length and compression scenarios. Additionally, new modules for cookie encoding (\NettyCookieEncoding\), query parameter handling (\NettyQueryParamEncoding\), and proxy configuration (\NettyProxy\) have been introduced to standardize data serialization within the Netty pipeline.

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

Scala 2-specific compiler macros and context aspects

This change introduces Scala 2 version-specific implementations for the ZIO HTTP library. It adds compiler macros for the \url\ string interpolator, enabling compile-time validation and optimization of URL construction, and provides an \md\ interpolator for CommonMark documentation. Additionally, it implements \HandlerVersionSpecific\ and \RoutesCompanionVersionSpecific\ to support applying context aspects via the environment, allowing handlers and routes to access contextual data (such as request context) through ZIO's environment layer rather than function parameters.

zio-http/shared/src/main/scala-2/zio/http · high confidence

WebSocket configuration parameters are now applied to the Netty protocol

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

Website migration to ziohttp.com with AI agent integration and SEO improvements

The website has moved to the ziohttp.com domain, with all traffic from the old zio-http.netlify.app domain automatically redirected. To support AI coding assistants, a new 'Get started' guide explains how to install ZIO skills for tools like Claude Code, Cursor, and others, ensuring they use up-to-date documentation. Additionally, search engine optimization is improved via a robots.txt file that excludes search result pages from indexing and points to the sitemap, while a context7.json file configures external LLM text services.

website/static · high confidence

Website rebuilt with Docusaurus 3, Tailwind CSS, and new branding assets

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

Test coverage

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 template2 CSS, JS, and DOM rendering; 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 HTTP generation from endpoint definitions; 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 OpenAPI schema generation and security scheme serialization; Added tests for OpenAPI to Endpoint code generation; Added tests for RFC 1123 date encoding; Added tests for Scala 3 OpenAPI generation edge cases; Added tests for SegmentCodec combination rules and hash stability; Added tests for field normalization and OpenAPI code generation; Added tests for gRPC content codec encoding and decoding; 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.

Dependencies

New authentication examples and website dependencies

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.

How this codebase got here

Score

  • CAI 51 → 48 (-3.1)

Lenses

  • Code Health 63 → 63 (+0.0)
  • Architecture 74 → 73 (-0.9)
  • Maturity 61 → 60 (-0.1)
  • Readiness 60 → 60 (-0.3)
  • Security 42 → 42 (+0.0)
  • Accessibility 54 → 42 (-11.9)
  • Performance 76 → 76 (+0.0)

Resolved (4)

  • Documentation: no usage examples (docs/examples/endpoint-scala3.md)
  • Off-boarding risk: anonymized user #1
  • Release-publishing job runs with an unscoped token
  • Workflow holding a long-lived secret is unscoped

New (67)

  • Off-boarding risk: anonymized user #1
  • Orphaned file (project/ScalaSettings.scala)
  • Orphaned file (sbt-zio-http-grpc/src/main/scala/zio/http/grpc/ZIOHttpGRPCGen.scala)
  • Orphaned file (zio-http-benchmarks/src/main/scala/zhttp.benchmarks/ClientBenchmark.scala)
  • Orphaned file (zio-http-benchmarks/src/main/scala/zhttp.benchmarks/ServerInboundHandlerBenchmark.scala)
  • Orphaned file (zio-http-cli/src/main/scala/zio/http/endpoint/cli/CliEndpoint.scala)
  • Orphaned file (zio-http-cli/src/main/scala/zio/http/endpoint/cli/HttpCliApp.scala)
  • Orphaned file (zio-http-example/src/main/scala/example/CombinerTypesExample.scala)
  • Orphaned file (zio-http-example/src/main/scala/example/MultipartFormData.scala)
  • Orphaned file (zio-http-example/src/main/scala/example/MultipartFormDataStreaming.scala)
  • Orphaned file (zio-http-example/src/main/scala/example/endpoint/CliExamples.scala)
  • Orphaned file (zio-http-gen/src/main/scala/zio/http/gen/openapi/Config.scala)
  • Orphaned file (zio-http-htmx/src/main/scala/zio/http/htmx/Attributes.scala)
  • Orphaned file (zio-http-tools/src/main/scala/zio/http/tools/GenerateMediaTypes.scala)
  • Orphaned file (zio-http/js/src/main/scala/zio/http/internal/FetchBodyInternal.scala)
  • Orphaned file (zio-http/jvm/src/main/scala/zio/http/netty/ChannelFactories.scala)
  • Orphaned file (zio-http/jvm/src/main/scala/zio/http/netty/EventLoopGroups.scala)
  • Orphaned file (zio-http/jvm/src/main/scala/zio/http/netty/NettyChannel.scala)
  • Orphaned file (zio-http/jvm/src/main/scala/zio/http/netty/NettyConfig.scala)
  • Orphaned file (zio-http/jvm/src/main/scala/zio/http/netty/NettyCookieEncoding.scala)
  • …and 47 more

Changes since last survey

  • 14 commits — 14 feature/other, 0 fixes

By area

  • website/yarn.lock — 11 commits
  • .github/workflows — 1 commit
  • project/Dependencies.scala — 1 commit
  • project/plugins.sbt — 1 commit

Notable commits

  • change: Update brotli4j to 1.24.0 (#4344)
  • change: Update sbt-github-actions to 0.32.2 (#4343)
  • change: chore(deps): bump body-parser from 1.20.6 to 1.20.9 in /website (#4346)
  • change: chore(deps): bump compression from 1.8.1 to 1.8.2 in /website (#4333)
  • change: chore(deps): bump fast-uri from 3.1.7 to 3.1.8 in /website (#4334)
  • change: chore(deps): bump fast-uri from 3.1.8 to 3.1.9 in /website (#4347)
  • change: chore(deps): bump joi from 17.13.7 to 17.13.8 in /website (#4335)
  • change: chore(deps): bump js-yaml from 3.14.1 to 3.15.2 in /website (#4349)
  • change: chore(deps): bump launch-editor from 2.14.1 to 2.14.2 in /website (#4345)
  • change: chore(deps): bump postcss-selector-parser from 6.1.2 to 6.1.5 in /website (#4348)
  • change: chore(deps): bump proxy-addr from 2.0.7 to 2.0.8 in /website (#4332)
  • change: chore(deps): bump scala-steward-org/scala-steward-action from 2.96.0 to 2.97.0 (#4340)
  • change: chore(deps): bump shell-quote from 1.10.0 to 1.12.0 in /website (#4330)
  • change: chore(deps): bump source-map-js from 1.2.1 to 1.2.2 in /website (#4331)

Architecture

  • Containers 0 added · 0 removed · contexts 0 added · 0 removed · edges 4 added · 4 removed

Added dependency edges (4)

  • zio-http-example-jwt-bearer-refresh-token-auth → zio-http-example-cookie-auth (coupling)
  • zio-http-example-jwt-bearer-token-auth → zio-http-example-cookie-auth (coupling)
  • zio-http-example-opaque-bearer-token-auth → zio-http-example-cookie-auth (coupling)
  • zio-http-example-webauthn → zio-http-example-cookie-auth (coupling)

Removed dependency edges (was a dependency, now gone) (4)

  • zio-http-example-jwt-bearer-refresh-token-auth → zio-http-example-cookie-auth
  • zio-http-example-jwt-bearer-token-auth → zio-http-example-cookie-auth
  • zio-http-example-opaque-bearer-token-auth → zio-http-example-cookie-auth
  • zio-http-example-webauthn → zio-http-example-cookie-auth

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

Survey your own repository

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.

About this page

  • The score is its most recent published measurement, taken on 26 October 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 5f50213236159f559b89d6cdf367d27391d86401 — the exact code this score is about.
  • Scored under rubric-2026.10.5 — the same rubric and the same method as every other entry in this index.
  • Measured by watchdog.canine.dev using codehealth-analyzer measure-2026.10.34+preprod-c12eef3a1477.