Skip to content
CAI
Software that uses CAICheck a score

actix/actix-web

59.6

Adequate · 14 November 2026

66.6k

lines of production code

Rust

primary language

7

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add TLS-enabled HTTP client example

A new example file demonstrates how to construct and use a TLS-capable HTTP client using the awc library. It shows configuring rustls with platform verification, setting ALPN protocols for HTTP/2 and HTTP/1.1, and making a GET request to https://www.rust-lang.org/.

awc/examples · high confidence

Add streaming content-encoding compression and decompression

The \actix-http/src/encoding\ module now provides built-in support for compressing and decompressing HTTP response and request bodies using gzip, deflate, brotli, and zstd. This change introduces \Encoder\ and \Decoder\ types that handle streaming data, offloading heavy compression tasks to a thread pool when chunks exceed 1024 bytes (encoding) or 2048 bytes (decoding) to prevent blocking the async runtime. The implementation respects feature flags (e.g., \compress-gzip\, \compress-brotli\, \compress-zstd\) to include only the selected algorithms, and automatically skips compression for empty bodies, 204/206 status codes, or when the \Content-Encoding\ header is already present.

actix-http/src/encoding · high confidence

Add typed multipart form field extractors

The \actix-multipart/src/form\ module now provides typed field readers that allow users to extract multipart form fields directly into strongly-typed Rust structs. This includes \Bytes\ for raw binary data, \Json\<T\>\ for deserializing JSON payloads, \Text\<T\>\ for plain text with UTF-8 and serde validation, and \TempFile\ for streaming file uploads to temporary disk storage. These types implement the \FieldReader\ trait and integrate with the \MultipartForm\ derive macro, enabling automatic parsing, content-type validation, and limit enforcement for each field type.

actix-multipart/src/form · high confidence

Added multipart form upload example with configurable size limits

A new example file (form.rs) demonstrates how to handle multipart form uploads in an Actix Web application, including parsing JSON metadata and temporary files. The example configures a 100MB total limit for the multipart form data using MultipartFormConfig to prevent excessive resource consumption during uploads.

actix-multipart/examples · high confidence

Initial release of actix-web-codegen macros

This change introduces the \actix-web-codegen\ crate, providing procedural macros for defining HTTP route handlers and application scopes. Users can now use attributes like \\#\[get\]\, \\#\[post\]\, \\#\[route\]\, and \\#\[routes\]\ to declaratively register handlers with path patterns, HTTP method guards, and middleware. The crate also includes a \\#\[scope\]\ macro to prefix paths within a module and a \\#\[main\]\ macro to bootstrap the Actix async runtime.

actix-web-codegen/src · high confidence

Initial support for route and HTTP method introspection

Actix Web now includes an experimental \experimental-introspection\ feature that allows applications to inspect their configured routes, HTTP methods, and guards at runtime. This feature adds an \IntrospectionCollector\ to the application builder and service configuration, collecting metadata about registered services, scopes, and resources. The collected data is exposed as a serializable report containing route paths, method guards, guard details, and reachability hints, which is useful for debugging routing issues or generating documentation, though it is intended for local or non-production use.

actix-web/src · high confidence

Introduce actix-http-test crate for integration testing

The \actix-http-test\ crate is introduced to provide helpers for writing integration tests for Actix applications. It exposes a \test\_server\ function that starts an HTTP server in a separate thread and returns a \TestServer\ controller. This controller allows users to construct URLs and send HTTP requests (GET, POST, HEAD) via an internal \awc::Client\, supporting both plain HTTP and HTTPS (when the \openssl\ feature is enabled).

actix-http-test/src · high confidence

Introduce typed HTTP header types for charset, content encoding, and quality values

This change adds new typed structs and enums to the \actix-http\ header module to provide safer, more ergonomic handling of common HTTP header components. Users can now work with strongly-typed \Charset\ values (supporting standard encodings like UTF-8, ISO-8859-1, and Big5), \ContentEncoding\ (including support for zstd, brotli, gzip, and deflate), and \Quality\/\QualityItem\ for parsing and formatting q-factor values in headers like Accept-Encoding. It also introduces \HttpDate\ for standardized HTTP date formatting and \ExtendedValue\ for parsing RFC 5987 extended header parameters, replacing previous ad-hoc string parsing with validated, reusable types.

actix-http/src/header/shared · high confidence

Introduce typed multipart form extractor via derive macro

Adds the \MultipartForm\ derive macro in \actix-multipart-derive\, enabling users to define structs that automatically implement \MultipartCollect\ for extracting typed multipart form data in Actix Web. The macro supports field-level configuration via \\#\[multipart\]\ attributes, including renaming fields (\rename\), setting size limits (\limit\ using the \bytesize\ crate), and controlling behavior for duplicate or unknown fields (\duplicate\_field\ and \deny\_unknown\_fields\).

actix-multipart-derive/src · high confidence

New Acceptable guard and Host guard refactoring

Actix Web introduces a new \Acceptable\ guard that allows routes to be matched based on the request's \Accept\ header, enabling content-negotiation at the routing level with optional support for wildcard MIME types. Additionally, the existing \Host\ guard has been refactored into its own module and updated to ignore the \Host\ header for HTTP/2 requests, falling back to the request URI's host instead, which aligns with HTTP/2 specifications where the Host header is not used.

actix-web/src/guard · high confidence

New JSON body parsing and response handling in awc

The \awc\ client now includes a \JsonBody\ type that allows users to consume HTTP response bodies as deserialized JSON objects. This new capability checks the \Content-Type\ header for \application/json\ and parses the payload using \serde\, respecting a configurable size limit (defaulting to 2 MiB) and optional timeouts. The change also introduces a \ResponseBody\ type for reading raw bytes, deprecating the previous \MessageBody\ alias, and restructures the response handling logic into dedicated modules for body reading and JSON parsing.

awc/src/responses · high confidence

New \`Html\` responder and \`Either\` extractor for polymorphic payloads

Actix Web now includes a dedicated \Html\ responder that automatically sets the \text/html\ content type and returns a 200 OK status, simplifying the return of raw HTML strings. Additionally, the new \Either\ extractor allows handlers to accept multiple payload formats (such as JSON or URL-encoded forms) by trying the primary extractor first and falling back to the secondary one, while \Either\ can also be used as a responder to return different response types based on logic.

actix-web/src/types · high confidence

New actix-test crate for integration testing

The \actix-test\ crate is introduced to provide integration testing tools for Actix Web applications. It exposes a \TestServer\ that spawns a real HTTP server on an unused port, allowing tests to interact with the application via a real HTTP client rather than in-memory service initialization. The crate re-exports key testing utilities from \actix\_web::test\ (such as \TestRequest\, \call\_service\, and \status\_service\) and \awc\ (such as \Client\ and \Connector\), while also providing configuration options for the test server including TLS support (via OpenSSL and multiple Rustls versions), HTTP version selection (HTTP/1 and HTTP/2), worker count, and client request timeouts.

actix-test/src · high confidence

New client middleware system with redirect handling

The awc client now supports a middleware architecture, allowing users to compose custom request transformations. This release introduces a built-in \Redirect\ middleware that automatically follows HTTP redirects (3xx status codes) up to a configurable limit (default 10), reusing connection state and handling body/method adjustments according to standard redirect rules. The underlying \Transform\ trait and \NestTransform\ helper enable chaining multiple middleware components for advanced client behavior.

awc/src/middleware · high confidence

New examples for from\_fn middleware, route introspection, and connection handling

The examples directory now includes standalone samples demonstrating several capabilities: \from\_fn.rs\ and \middleware\_from\_fn.rs\ show how to create and use the new \from\_fn\ middleware for request processing; \introspection.rs\ and \introspection\_multi\_servers.rs\ showcase the experimental route and HTTP method introspection feature (enabled via the \experimental-introspection\ feature flag), allowing users to inspect and report on registered routes and external resources; \on-connect.rs\ demonstrates using \HttpServer::on\_connect\ to access low-level socket properties like client address and TTL; \basic.rs\ and \macroless.rs\ provide standard and macro-free server setup patterns; \uds.rs\ shows binding to Unix domain sockets; and \worker-cpu-pin.rs\ illustrates pinning workers to specific CPU cores. Also in this area: 2 commits (0 fixes) modifying actix-files, actix-multipart, actix-web; Clarified server startup timing and added readiness example; Add first-class support for the HTTP QUERY method.

actix-web/examples · medium confidence · unverified

New middleware utilities and expanded documentation

The middleware module now includes a \Compat\ wrapper to allow middleware with incompatible body types to be used on scopes and resources, a \from\_fn\ helper to create middleware from simple async functions, and an \Identity\ no-op middleware. The \Condition\ middleware is now generic over body types, and the \ErrorHandlers\ middleware supports setting default handlers for all client or server errors. Additionally, the \Logger\ middleware now supports configurable log levels and custom request/response replacements, and a comprehensive Middleware Author's Guide has been added.

actix-web/src/middleware · high confidence

New release and CI maintenance scripts

Added four new shell scripts to the \scripts/\ directory: \bump\ automates version updates for Cargo crates by updating \Cargo.toml\, \README.md\, and changelog files (supporting both \CHANGELOG.md\ and \CHANGES.md\), and can optionally update cross-crate dependencies and create GitHub release drafts; \unreleased\ displays pending changelog entries for all crates; \publish\ streamlines the multi-crate publishing process with dry-run checks and handling for cyclic dev-dependencies; and \free-disk-space.sh\ cleans up large packages and directories on CI runners to prevent build failures due to disk space exhaustion.

scripts · high confidence

New response customization and status code builder APIs

Actix-web introduces a \.customize()\ method on the \Responder\ trait, allowing handlers to override the status code and headers (including cookies via \add\_cookie\) of any response type without manually constructing an \HttpResponse\. Additionally, \HttpResponse\ now provides static constructor methods for all standard HTTP status codes (e.g., \HttpResponse::Ok()\, \HttpResponse::NotFound()\), simplifying response creation. The \HttpResponseBuilder\ also gains a \no\_chunking\ method to disable chunked transfer encoding for streaming responses when the content length is known.

actix-web/src/response · high confidence

New typed HTTP header implementations

This location introduces a comprehensive set of strongly-typed HTTP header implementations, including Accept, Accept-Charset, Accept-Encoding, Accept-Language, Cache-Control, Content-Length, ETag, Range, and others. These types provide structured parsing and formatting for request and response headers, replacing raw string handling with type-safe abstractions that support features like q-factor weighting, content negotiation, and wildcard handling.

actix-web/src/http/header · high confidence

actix-multipart v0.7.0: Complete rewrite with typed form extraction and testing utilities

The actix-multipart crate has been rewritten for version 0.7.0, introducing a new \MultipartForm\ extractor and derive macro that allows users to define typed structs (using Serde) to automatically parse multipart/form-data requests into structured data. The core \Multipart\ stream extractor now supports \multipart/related\ and \multipart/mixed\ in addition to \form-data\, while explicitly removing support for nested multipart streams. A new \Field::bytes()\ method enables collecting field data with configurable size limits, and a \test\ module provides utilities like \create\_form\_data\_payload\_and\_headers\ to simplify writing tests for multipart endpoints. The error model has been expanded to include specific variants for missing content types, boundaries, and duplicate/missing fields, and the \MultipartConfig\ no longer implements \Copy\.

actix-multipart/src · high confidence

actix-web-codegen 4.5.0 release notes and MSRV update

This change introduces the release notes for actix-web-codegen version 4.5.0, which adds a new \\#\[query\]\ route handler macro and support for the \method = "QUERY"\ option in the \\#\[route\]\ macro. It also raises the Minimum Supported Rust Version (MSRV) to 1.89. The diff additionally includes the creation of the changelog file, license symlinks, and a README for the crate.

actix-web-codegen · high confidence

awc 3.9.0 release: WebSocket camel-case headers and hickory-resolver update

The awc HTTP and WebSocket client library has been updated to version 3.9.0. This release adds camel-case header controls to \WebsocketsRequest\ via the new \camel\_case\_headers()\ and \set\_camel\_case\_headers()\ methods, allowing users to manage header formatting for WebSocket connections. Additionally, the \hickory-resolver\ dependency has been updated to version 0.26.

awc · high confidence

Architecture

Repository restructured with new tooling and configuration files

The repository has been reorganized to support a multi-crate workspace structure. A new justfile has been added to standardize build, test, and documentation commands across the workspace, including MSRV checks and feature combination validation. Several configuration files have been introduced: .clippy.toml to enforce coding standards (e.g., disallowing 'e' bindings), .rustfmt.toml for import grouping, .taplo.toml for TOML formatting, .codecov.yml for coverage thresholds, .cspell.yml for spell checking, and zizmor.yml for GitHub Actions security hardening. The root README.md has been converted into a symlink, and a new CODE\_OF\_CONDUCT.md and CHANGES.md (redirecting to crate-specific changelogs) have been added. The license file was renamed to LICENSE-APACHE, and a separate LICENSE-MIT file was created.

(repo-wide) · high confidence

Behavioural changes

2 commits (0 fixes) modifying actix-files, actix-multipart, actix-web

A change to existing behaviour in actix-files, actix-multipart, actix-web — 2 commits, 72 files: “test: replace Actix test attributes with Tokio local tests (\#4417)”; “chore: replace example main macros with Tokio (\#4416)” (refs \#4417, \#4416). Also in this area: Opt-in synchronous file reads for smaller files.

actix-files/examples · medium confidence · unverified

Actix Web 4.15.0 release with TLS and HTTP/2 feature decoupling

This release introduces a behavioral change where the TLS crate features (such as \rustls-0\_22\ and \rustls-0\_23\) no longer automatically enable the \http2\ crate feature, requiring users to explicitly enable HTTP/2 support if needed. Additionally, the experimental \experimental-io-uring\ crate feature has been removed.

actix-web · high confidence

Awc HTTP client library restructured with new builder and body abstractions

The awc crate has been reorganized into a new modular structure, introducing a dedicated \ClientBuilder\ for configuring HTTP clients (including timeouts, redirects, and HTTP/2 window sizes) and a \FrozenClientRequest\ type to enable cloning and retrying prepared requests. A new \AnyBody\ enum standardizes how various HTTP message body types are handled internally, while the \connect\ module now explicitly manages combined HTTP and WebSocket connection logic via \ConnectRequest\ and \ConnectResponse\ types. The public API surface has been refined with new error types like \WsClientError\ and \JsonPayloadError\, and the library now exports a \ws\ sub-module for WebSocket-specific types and functionality.

awc/src · high confidence

Awc client module restructured with new connection pooling and TLS support

The HTTP client implementation in \awc/src/client\ has been reorganized into dedicated modules (\config\, \connection\, \connector\, \pool\, \h1proto\, \h2proto\) to improve maintainability. This change introduces a new connection pooling system (\pool.rs\) that manages HTTP/1 and HTTP/2 connections, including graceful shutdown handling for H1 connections. It also adds support for Rustls v0.23 (via \rustls-0\_23\ features) alongside existing TLS backends (OpenSSL, Rustls v0.20–0.22). The HTTP/2 protocol handler (\h2proto.rs\) now correctly omits the \Host\ header for HTTP/2 requests and handles GO\_AWAY errors by closing connections. Additionally, error types have been migrated from \actix\_connect\ to \actix\_tls\, and the \SendRequestError\ enum has been extended with a \Custom\ variant for better error reporting.

awc/src/client · high confidence

HTTP service configuration and builder restructured

The \actix-http\ crate introduces a new \HttpServiceBuilder\ and \ServiceConfig\ API for configuring HTTP services, replacing previous patterns. Users can now explicitly set connection keep-alive timeouts, client request and disconnect timeouts, \TCP\_NODELAY\ settings, and HTTP/1 half-close behavior. The builder also exposes configuration for HTTP/2 flow control window sizes (both connection and stream levels) and HTTP/1 write buffer sizes. Additionally, a \Protocol\ enum is added to distinguish between HTTP/1, HTTP/2, and HTTP/3 variants, and the \Extensions\ type gains \get\_or\_insert\ and \get\_or\_insert\_with\ methods for more ergonomic insertion of request-local data.

actix-http/src · high confidence

HTTP/1.1 protocol implementation refactored and hardened

The HTTP/1.1 implementation in \actix-http/src/h1\ has been significantly refactored to improve security, correctness, and maintainability. A new dedicated \chunked.rs\ module now handles chunked transfer encoding parsing, enforcing stricter validation against oversized chunk sizes and illegal characters. The message decoder (\decoder.rs\) now rejects multiple \Content-Length\, \Transfer-Encoding\, and \Host\ headers to prevent request smuggling, and correctly handles \Transfer-Encoding\ variations per RFC 9112. The dispatcher (\dispatcher.rs\) introduces new states for graceful shutdown (\DRAINING\) and lingering after early responses (\LINGER\), while buffer sizes are standardized. Internal APIs have been modernized, including renaming \keepalive\ to \keep\_alive\, replacing \LocalWaker\ with standard \Waker\ in the payload stream, and migrating from \actix\_codec\ to \tokio\_util::codec\. Comprehensive tests have been added to verify these behavioral changes.

actix-http/src/h1 · high confidence

HTTP/2 implementation refactored with keep-alive and configurable window sizes

The HTTP/2 protocol handling in \actix-http\ has been restructured to support connection keep-alive via ping-pong frames and expose configuration for HTTP/2 flow-control window sizes. The new dispatcher logic manages idle connections by sending periodic pings and resetting timers based on a configurable deadline, ensuring connections remain open when active. Additionally, the handshake process now allows setting initial stream and connection window sizes via \ServiceConfig\, giving users control over backpressure and throughput for HTTP/2 streams.

actix-http/src/h2 · high confidence

New error handling API with response mappers and standardized error types

Actix Web introduces a new \Error\ type that supports adding response mappers, allowing users to modify the HTTP response generated for an error (e.g., adding headers) without discarding the original error details. The \ResponseError\ trait is now the central abstraction for errors that can be converted to HTTP responses, with implementations for standard library errors, \Infallible\, and various payload errors. Helper functions like \ErrorBadRequest\ and \ErrorInternalServerError\ are provided to wrap errors with specific status codes. The module also includes \InternalError\ for wrapping arbitrary errors with custom status codes or responses, and \UrlencodedError\ and \JsonPayloadError\ for handling payload parsing issues with appropriate status codes.

actix-web/src/error · high confidence

New modular body types and streaming utilities

The body module has been restructured into distinct components, introducing \BodyStream\ and \SizedStream\ to wrap asynchronous streams as HTTP bodies, with \SizedStream\ allowing explicit size hints to avoid chunked transfer encoding. A new \EitherBody\ type simplifies middleware composition by allowing conditional return of inner service bodies or error responses. The \BoxBody\ type now provides a unified, boxed representation of message bodies with erased error types, and the \MessageBody\ trait is standardized with an associated \Error\ type. Additionally, \to\_bytes\_limited\ is added to safely collect body bytes with a configurable memory limit, returning a \BodyLimitExceeded\ error if the threshold is breached.

actix-http/src/body · high confidence

Opt-in synchronous file reads for smaller files

The static file serving service now supports an opt-in threshold that allows small files to be read synchronously, bypassing the async blocking thread pool. This change introduces a \read\_mode\_threshold\ configuration option on both the \Files\ service and \NamedFile\; files smaller than this threshold are read directly on the current thread, while larger files continue to use the async \web::block\ approach. This provides a performance optimization for small assets by reducing context-switching overhead.

actix-files/src · high confidence

Refactored HTTP response handling with dedicated builder and head modules

The response subsystem has been restructured into separate modules (\builder.rs\, \head.rs\, \response.rs\) to improve code organization. This change introduces a \ResponseBuilder\ for constructing responses via a fluent API, extracts the \ResponseHead\ structure into its own file with a thread-local object pool for performance, and exposes these components publicly. Users can now build responses using \Response::build()\ and manipulate headers and status codes through the new builder pattern, while the underlying head management is optimized via pooling.

actix-http/src/responses · high confidence

Refreshed actix-http examples with Rustls 0.23 and modern service APIs

The example suite in actix-http has been updated to demonstrate current best practices. TLS examples (tls\_rustls.rs, ws.rs) now use Rustls 0.23 via the rustls\_0\_23 crate, and the WebSocket example supports both TCP and TLS bindings. A new h2c-detect.rs example shows automatic HTTP/2 cleartext upgrade using tcp\_auto\_h2c(). All examples have migrated to the HttpService builder API (e.g., .finish(), .h1(), .h2()) and use tracing for logging, replacing older patterns like direct body construction or manual timeout configuration.

actix-http/examples · high confidence

Request structure refactored with dedicated head module and connection data support

The request handling logic has been reorganized by extracting the request head definition into a dedicated \head.rs\ module, which introduces a \RequestHeadType\ enum to manage owned or reference-counted heads with optional extra headers. The main \Request\ struct now defaults to \BoxedPayloadStream\ instead of \PayloadStream\ and includes new fields for connection-level data (\conn\_data\) and request-local extensions (\extensions\), enabling access to connection metadata via \conn\_data()\ and \take\_conn\_data()\ methods. Additionally, the request head now supports configurable Camel-Case header formatting via \set\_camel\_case\_headers()\.

actix-http/src/requests · high confidence

Reworked header module with new traits and constants

The header module has been restructured to introduce new conversion traits (\TryIntoHeaderValue\, \TryIntoHeaderPair\) and a sealed \AsHeaderName\ trait for more flexible header handling. The internal \HeaderMap\ implementation has been updated to use \foldhash\ instead of \ahash\ for improved performance. Additionally, several new header name constants have been added, including \CACHE\_STATUS\, \CDN\_CACHE\_CONTROL\, \CLEAR\_SITE\_DATA\, and various cross-origin policy headers.

actix-http/src/header · high confidence

WebSocket implementation refactored into modular components

The WebSocket module in \actix-http\ has been restructured into distinct files (\codec.rs\, \dispatcher.rs\, \frame.rs\, \mask.rs\, \proto.rs\) to improve code organization and maintainability. This change introduces a dedicated \Codec\ for encoding/decoding WebSocket frames, a \Dispatcher\ for handling the async I/O loop between the transport and the application service, and a \Parser\ for frame validation. Key behavioral updates include stricter validation of WebSocket frames (e.g., rejecting non-zero reserved bits, validating close frame payloads, and enforcing masking rules), support for continuation frames, and the addition of a \Nop\ message type for low-level services. The public API exposes these components via \mod.rs\, allowing users to interact with WebSocket sessions through the new \Dispatcher\ and \Codec\ abstractions.

actix-http/src/ws · high confidence

actix-files 0.7.0 release notes and license updates

The \actix-files\ crate has reached version 0.7.0, introducing several breaking and new features: the experimental \io-uring\ support (including \NamedFile::open\_async\) has been removed, while new capabilities include passing multiple root directories to \Files::new\ and serving pre-compressed static files via \Files::try\_compressed()\. This release also fixes several behavioral issues, such as panics when handling hidden files with dot segments or pre-epoch modification times, incorrect \Content-Encoding\ headers in range responses, and improper handling of \Range: bytes=0-\. Additionally, license files (Apache-2.0 and MIT) have been added as symlinks, and the README has been updated to reflect the current version and MSRV requirements.

actix-files · high confidence

actix-http 3.18.12 release notes

The actix-http crate has been updated to version 3.18.12. This release includes a fix to flush compressed response bodies when the source is pending, ensuring that data is sent to the client promptly even if the underlying data source is temporarily blocked. The changelog also documents previous fixes in versions 3.18.11 through 3.13.1, covering security improvements for HTTP/1 request smuggling, WebSocket frame validation, and various connection handling and header encoding behaviors.

actix-http · high confidence

actix-multipart 0.8.0 introduces buffering limits and new form extraction features

The actix-multipart crate has been updated to version 0.8.0, introducing a 64KB buffer cap for multipart parsing to prevent unbounded memory growth on malformed bodies (configurable via \MultipartConfig::buffer\_limit\) and fixing user-triggerable panics during boundary parsing. New capabilities include multi-field multipart payload builders in the \test\ module for easier testing, support for \Option\<Vec\<T\>\>\ fields in \MultipartForm\ typed extractors, and a new \Field::bytes()\ method. The minimum supported Rust version (MSRV) has been raised to 1.88, and the \rand\ dependency has been updated to version 0.10.

actix-multipart · high confidence

actix-router 0.5.4 release notes and documentation

This change introduces the changelog, license symlinks, and README for the actix-router crate, documenting the 0.5.4 release. The release notes highlight that the minimum supported Rust version (MSRV) has been raised to 1.88, the PathDeserializer now supports deserialize\_any to enable derived untagged enums in path segments, and a fix prevents out-of-bounds access during extraction by correcting stale path segment indices after path rewrites. The entry also covers the unreleased feature allowing multi-component path parameters to be extracted into sequences.

actix-router · high confidence

actix-router v0.6.0 introduces path deserialization and regex feature flags

This release of the actix-router library introduces a new \PathDeserializer\ (in \de.rs\) that allows routing parameters to be deserialized directly into Rust structs using Serde, supporting maps, tuples, and enums. It also adds a \unicode\ crate feature that lets users choose between the full-featured \regex\ crate and the smaller \regex-lite\ crate to trade off Unicode support for binary size. Additionally, the \Path::path\ method is deprecated in favor of \as\_str()\ and \unprocessed()\, and the \Quoter::requote\ method now returns a \Vec\<u8\>\ instead of an \Option\<Vec\<u8\>\>\ to improve performance.

actix-router/src · high confidence

actix-test 0.1.5 release with TestServer configuration and MSRV update

The actix-test crate has been updated to version 0.1.5, raising the Minimum Supported Rust Version (MSRV) to 1.88. This release introduces the \TestServerConfig::listen\_address()\ method, allowing users to configure the address on which the test server listens. The changelog also documents previous updates including Rustls v0.21, v0.22, and v0.23 support, redirect disabling, and various re-exports from awc and actix\_http.

actix-test · high confidence

actix-web-actors deprecated with new WsResponseBuilder and API updates

The \actix-web-actors\ crate is now deprecated in favor of \actix-ws\. The WebSocket API has been updated to use \ByteString\ for text messages and introduces a \WsResponseBuilder\ for configuring session parameters like frame size and protocols. Additionally, the \HttpContext\ stream now yields \Result\<Bytes, Error\>\ items, and internal dependencies have been migrated to \tokio\ and \futures-core\.

actix-web-actors/src · high confidence

actix-web-actors is deprecated with MSRV bump to 1.88

The actix-web-actors crate is now marked as deprecated, and users are advised to migrate to the actix-ws crate. This release also updates the Minimum Supported Rust Version (MSRV) to 1.88.

actix-web-actors · high confidence

Test coverage

5 commits adding/updating tests in actix-multipart/tests; Added HTTP date formatting and response body compression benchmarks; Added benchmark suite for responder, server, and service performance; Added benchmarking suite for router and quoter performance; Added comprehensive integration tests for the AWC HTTP client; Added integration and compile-time tests for route, scope, and trybuild macros; Added integration tests for HTTP/1.1, HTTP/2, TLS, and WebSocket protocols; Added integration tests for WebSocket response builder; Added test coverage for compression, introspection, and server lifecycle; Added tests for file serving edge cases and security; Added trybuild tests for route, scope, and routes macros; New internal test helpers for HTTP testing; New test utilities module for actix-web.

Dependencies

Initial dependency lock and manifest setup for Actix Web workspace

The project now includes a generated \Cargo.lock\ file and updated \Cargo.toml\ manifests for the Actix Web workspace, establishing a pinned dependency graph for core crates such as \actix-http\ (3.18.12), \actix-files\ (0.7.0), \actix-multipart\ (0.8.5), and \awc\ (3.x). This change ensures reproducible builds by locking all transitive dependencies to specific versions and checksums, replacing any previous state where dependencies might have been resolved dynamically or not fully tracked in the repository.

(dependencies) · high confidence

actix-multipart-derive 0.8.1 release with dependency updates

The actix-multipart-derive crate has been updated to version 0.8.1, which upgrades the \syn\ dependency to version 0.3 and the \darling\ dependency to version 0.24. This release also establishes a new Minimum Supported Rust Version (MSRV) of 1.88, requiring users to update their Rust toolchain to this version or higher to use this crate.

actix-multipart-derive · high confidence

Housekeeping

This change introduces the changelog for actix-http-test version 3.3.0, which removes the unused direct actix-tls dependency and raises the Minimum Supported Rust Version (MSRV) to 1.88. It also adds license symlinks (LICENSE-APACHE and LICENSE-MIT) and a README for the crate.

actix-http-test · high confidence

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

How this codebase got here

Score

  • CAI 59 → 60 (+0.2)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 66 → 65 (-0.9)
  • Architecture 94 → 94 (+0.1)
  • Maturity 63 → 67 (+4.1)
  • Readiness 86 → 85 (-0.2)
  • Security 46 → 45 (-0.9)
  • Performance 100 → 100 (+0.0)

Resolved (46)

  • Change coupling: builder.rs ↔ dispatcher.rs (actix-http/src/builder.rs)
  • Duplicated block (11 lines × 2) (actix-http/src/encoding/decoder.rs)
  • Duplicated block (11 lines × 2) (awc/src/request.rs)
  • Duplicated block (12 lines × 2) (actix-http/src/h1/service.rs)
  • Duplicated block (12 lines × 4) (actix-http/src/encoding/decoder.rs)
  • Duplicated block (12–13 lines × 5) (actix-web/src/server.rs)
  • Duplicated block (15 lines × 2) (actix-web/src/server.rs)
  • Duplicated block (15–16 lines × 2) (actix-http-test/src/lib.rs)
  • Duplicated block (20 lines × 5) (awc/src/client/connector.rs)
  • Duplicated block (37 lines × 2) (actix-http/src/h1/dispatcher.rs)
  • Duplicated block (5 lines × 2) (actix-http-test/src/lib.rs)
  • Duplicated block (7 lines × 2) (actix-web/src/resource.rs)
  • Duplicated block (7 lines × 4) (actix-http/src/h2/service.rs)
  • Duplicated block (8 lines × 2) (actix-web/src/app_service.rs)
  • Duplicated block (8 lines × 4) (actix-http/src/service.rs)
  • Duplicated block (9 lines × 2) (awc/src/responses/json_body.rs)
  • Duplicated block (9 lines × 7) (actix-web/src/server.rs)
  • High CVE: [GHSA redacted] (Cargo.lock)
  • High CVE: [GHSA redacted] (Cargo.lock)
  • Hotspot: actix-http/src/ws/frame.rs (actix-http/src/ws/frame.rs)
  • …and 26 more

New (114)

  • Duplicated block (10 lines × 2) (actix-web/src/app_service.rs)
  • Duplicated block (11 lines × 2) (actix-http/src/encoding/decoder.rs)
  • Duplicated block (11 lines × 6) (actix-test/src/lib.rs)
  • Duplicated block (12 lines × 4) (actix-http/src/encoding/decoder.rs)
  • Duplicated block (12 lines × 6) (actix-test/src/lib.rs)
  • Duplicated block (12 lines × 6) (actix-test/src/lib.rs)
  • Duplicated block (13 lines × 4) (actix-web/src/server.rs)
  • Duplicated block (15–19 lines × 2) (awc/src/request.rs)
  • Duplicated block (17–18 lines × 2) (awc/src/request.rs)
  • Duplicated block (18 lines × 7) (actix-web/src/server.rs)
  • Duplicated block (18–19 lines × 2) (actix-http-test/src/lib.rs)
  • Duplicated block (18–19 lines × 7) (actix-web/src/server.rs)
  • Duplicated block (20 lines × 5) (awc/src/client/connector.rs)
  • Duplicated block (20–23 lines × 2) (actix-http/src/h1/service.rs)
  • Duplicated block (5 lines × 2) (actix-http-test/src/lib.rs)
  • Duplicated block (51 lines × 2) (actix-http/src/h1/dispatcher.rs)
  • Duplicated block (6 lines × 2) (actix-http-test/src/lib.rs)
  • Duplicated block (7 lines × 2) (actix-web/src/introspection.rs)
  • Duplicated block (7 lines × 2) (actix-web/src/resource.rs)
  • Duplicated block (8 lines × 5) (actix-web/src/server.rs)
  • …and 94 more

Changes since last survey

  • 71 commits — 54 feature/other, 17 fixes

By area

  • (root) — 29 commits
  • actix-http/src — 10 commits
  • .github/workflows — 9 commits
  • actix-web/src — 4 commits
  • (repo) — 3 commits
  • actix-http/CHANGES.md — 3 commits
  • actix-files/src — 2 commits
  • actix-multipart/CHANGES.md — 2 commits
  • actix-web/README.md — 2 commits
  • .github/PULL_REQUEST_TEMPLATE.md — 1 commit
  • actix-files/CHANGES.md — 1 commit
  • actix-multipart/src — 1 commit
  • actix-multipart/tests — 1 commit
  • actix-web/examples — 1 commit
  • awc/src — 1 commit
  • scripts/bump — 1 commit

Notable commits

  • fix: fix(actix-http): add Decoder::limit()
  • fix: fix(bump): preserve equals in reference version requirements (#4399)
  • fix: fix(errors): normalize error and panic messages (#4391)
  • fix: fix(files): encode directory listing hrefs per path segment
  • fix: fix(files): merge Windows short-name protection
  • fix: fix(files): resolve windows shortnames as part of canonicalization
  • fix: fix(http): disable large-window Brotli decompression
  • fix: fix(http): merge bare LF chunk terminator fix
  • fix: fix(http): preserve framing after bodiless responses (#4398)
  • fix: fix(http): reject bare LF as last chunk terminator in chunked encodings
  • fix: fix(http): send HTTP/2 GOAWAY during graceful shutdown (#4401)
  • fix: fix(multipart): accept transport padding after boundary delimiters (#4358)
  • fix: fix(multipart): keep bare CR before boundary text as field data (#4376)
  • fix: fix(web): bound decompressed request payloads
  • fix: fix(web): encode non-ASCII attachment filenames (#4378)
  • fix: fix(web): return allowed methods for macro route mismatches (#4374)
  • fix: fix: enable TCP_NODELAY by default (#4395)
  • change: Merge branch 't3/encode-directory-listing-hrefs'
  • change: build(deps): bump actions-rust-lang/setup-rust-toolchain from 2.0.0 to 2.0.1 (#4406)
  • change: build(deps): bump base64 from 0.22.1 to 0.23.1 (#4364)
  • …and 51 more

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

Survey your own repository

actix/actix-web 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 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 0ac7d21619644f2e8d5ffbf8ccc87ac2d0e96542 — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-36d4cd83012f.