Changelog
Notable changes per release. Versions follow semver: a major version means a breaking change — see Migrating to 18.0 for the next one. Releases and binaries: GitHub releases.
18.38.0 — 2026-11-16
Added
- Maintenance mode can turn itself off. Turning it on takes a time to
end (
for_secs) and theRetry-Afterto send meanwhile (retry_after_secs, instead of[maintenance] retry_after_secs). The admin UI asks for both in the confirmation (retry after the configured value, 5 minutes, 15 minutes or 1 hour; off by itself after 1 hour, 4 hours or never), and while a time is set the banner shows when it ends with Add 1 hour and Turn off now. From a shell:rws ctl maintenance on --for 1h --retry-after 5mandrws ctl maintenance extend 1h; the MCP toolset_maintenancetakesfor_secsandretry_after_secs.Retry-Afternever points past the time maintenance ends, and the automatic turn-off is in the audit log as usertimer. Without a time, maintenance stays on until someone turns it off, as before. - Drain progress. rws counts the requests running on each upstream
backend (a streamed response or a WebSocket until it ends), so a drain
says when the backend is safe to stop. The admin UI's Upstreams page has
an "Open requests" column, and a drained backend gets a card: how many
requests are still running on it, then "safe to deploy" with Put
back. From a shell,
rws ctl drain <upstream> <backend> --wait 2mdrains and returns when no request is left (exit 1 when some still run after that time), andrws ctl upstreamshas anOPENcolumn.GET /upstreamsbackends haveopen_requestsanddrained_since; Prometheus hasrws_upstream_backend_open_requestsandrws_upstream_backend_drained. The count is per rws process. - Response time and where requests go. The admin UI's Overview shows
the p50, p95 and p99 response time, and a "Where requests go" card: the
busiest hosts and every upstream with its share of requests, its errors
and the time 95% of its requests stayed under, plus what rws answered
itself. Both cover the last five minutes the page has been open (since
start before that). They come from the new
GET /breakdownof the admin API: the response-time histogram with its percentiles, requests and5xxanswers perHost(up to 200 names, the rest added up), and requests, errors and response times per upstream. Host names are counted for the admin API only; they are not Prometheus labels. Library:admin::ops::breakdown_json(). - Edit the configuration file from the admin UI. With
[admin] edit_config = true(off by default) the Config page showsrws.config.tomlin an editor. Edits are staged: the page shows the lines that will change, checks the text asrws --checkdoes (a file that doesn't pass can't be applied) and names the settings a reload won't apply. Apply keeps the previous file asrws.config.toml.bak, writes the new one and reloads; if the reload refuses it, the previous file is put back. A write based on a file that changed on disk since is refused, and the page offers to compare. It is roleadmin's only, reading included, and the audit log records the file's SHA-256 before and after, not its text. Admin API:GET/PUT /config/fileandPOST /config/file/check. Not offered when[fleet]owns the file or rws runs without one. - Admin API:
GET/PUT /maintenanceanswer{"active":…,"since":…,"until":…,"retry_after_secs":…}(was{"active":…});PUT /maintenance {"add_secs":N}extends a timed maintenance;GET /statushasmaintenance_until. - Library:
maintenance::turn_on(for_secs, retry_after_secs),turn_off(),extend(add_secs),active()andstatus(). TheMAINTENANCE_MODEflag works as before.
Changed
- Admin UI: a new look and layout. Dark graphite with one orange accent. The sections are grouped in the sidebar as Observe (Overview, Traffic, Logs), Route (Upstreams, Certificates) and Operate (Controls, Config, Audit).
- Admin UI: a command palette.
Ctrl K(⌘ Kon a Mac) or/opens it: go to a section, drain or put back a backend, purge a cache, turn maintenance on or off, reload, unblock an address, find a setting, open the guides.Gthen a letter goes to a section (G Uis Upstreams; the letters are shown in the sidebar). - Admin UI: Overview shows what needs you. Requests per second with the errors, open connections and queue beside it, a chart with the value under the pointer, a "Needs attention" list (failing or drained backends, an open circuit breaker, certificates about to expire, a full disk) with the action next to each, and the newest requests.
- Admin UI: maintenance mode asks for the word. Turning it on lists
what visitors get and wants
maintenancetyped before the button works. - Admin UI: Upstreams shows each backend's share of traffic and the recent drains from the audit log; Logs can be downloaded as a file.
- Admin UI on a phone: rows of the upstream and cache tables stack, so Drain and Purge stay on screen.
- Admin API:
GET /upstreamslists upstreams by name (the order used to differ from one start or reload to the next).
18.37.0 — 2026-11-16
Changed
- Compatibility: the
rwsbinary rejects arguments it doesn't know. An unknown argument (--bogus,--prot=1,help me) or a flag without a value now stops rws with exit code 2 and a hint ("did you mean --port?") instead of being ignored while a server starts. Check service units and scripts that pass extra arguments. Applications built on the library keep their own arguments: only the binary checks. - Compatibility:
rws -hprints help (so dorws helpandrws --help).-h=<list>and--cors-allow-headers=<list>still set the allowed CORS headers. -p 8080works: every option takes its value after a space as well as after=.rws --checkreads the file as TOML. An unclosed[[route]header, an unclosed string or array, or a line that isn'tkey = valueis an error with line and column (it said "configuration OK" before); a bare word where TOML wants a quoted string is a warning. Unknown settings suggest the closest one ([admn] listen→[admin] listen), at startup too.- A quieter start. rws prints its version, where the configuration
came from, what it serves and the address, plus a warning when it
listens on all interfaces with directory listing on. The listener
lines scripts wait for stay ("serving plain HTTP/1.1", "Listening for
TLS connections", "Started N per-core runtimes").
--verbose(orRWS_VERBOSE=true) prints every setting as before. Norws.config.tomlin the working directory is no longer reported as "Unable to read". - A port in use is one line, not a panic: rws names the address and how to pick another port, and exits with code 1. So does a port below 1024 without permission.
rws --helpstarts with the commands, then the common options, then the ACME, CORS and other options in groups.- Error pages for browsers. A browser (an
Acceptthat preferstext/html) gets an HTML page for rws's own 502 and 503 and for maintenance mode: status, one sentence, a link home, light and dark,Vary: Accept. API clients get the same problem+json bodies as before. The built-in 404 uses the same template (a404.htmlin the working directory still replaces it). - Maintenance:
Retry-Afterand a message. Maintenance responses sendRetry-After: 120([maintenance] retry_after_secs, 0 sends none);[maintenance] messagereplaces the sentence on the page browsers see. - Directory listing on a phone. Below 600 px the Modified column is hidden and names wrap at word boundaries instead of mid-word; icons are inline SVG instead of emoji; the page title is the path; the time column says UTC.
- Admin UI: confirmations and Undo. Turning maintenance mode on,
emptying a response cache and draining the last healthy backend of an
upstream ask first and name the consequence; draining, unblocking and
blocking offer Undo. A cache has "Purge path" (its own field, a prefix
ending in
*) and "Purge all"; there is no shared path field any more. - Admin UI: a truthful header. One chip on every page: Disconnected
(with the last answer's time, retried every 5 s), Maintenance (plus a
banner with "Turn off" on every page), Degraded (N of M backends), Not
ready or Ready. Overview has a "Backends healthy" tile.
/statushas amaintenancefield. - The admin listener's own requests aren't counted. The UI's polling
no longer raises "Requests served" or fills the access log;
[admin] count_own_requests = truecounts them again. - Admin UI: Logs as columns (time, status, method, host and path, size, client) with a filter box and 2xx–5xx chips, wrapped, filling the window.
- Admin UI on a phone. The bottom bar has Overview, Traffic, Upstreams, Controls and More (a sheet with the rest); tables scroll inside themselves instead of the page; Traffic's tabs scroll with a fade and arrow keys move between them; nothing scrolls the page sideways.
- Admin UI: browser history and titles. Each section is a history entry, so Back returns to the previous one, and the tab is titled "Traffic · rws admin". The token field is focused on the sign-in page. Form errors (an address that isn't one) show at the field; action errors show as a message at the bottom, not at the top of the page.
- Traffic. Opens on Visitors. Old numbers stay, dimmed, while a new period loads; a failed load shows a Retry card. Without the traffic database rows are plain text and one line says how to turn filtering on (rows used to look clickable and end in a notice). "Compare" says when no earlier period is kept (30 days with the default retention). Full lists show 50 rows and "Show more", the visit feed has a filter box, "All N →" sits in each card's header, and empty scroll-depth rows read "Nothing in this period". Hour and day axis labels name whole hours and days; the legend no longer repeats the line labels. "What do these mean?" explains Verified, Likely, Page only and Server networks; the live count reads "N in the last 5 min" everywhere.
- rws8.tech. Search is in the header of every page (and
/, Ctrl+K): arrow keys move through the results, Enter opens one, a page's matching sections are listed under it, and excerpts lost the stray#of heading anchors. The docs version menu opens over the sidebar with the five newest versions and the rest under "Older versions", and closes on Esc. Below 1200 px an "On this page" list sits under the title. The changelog shows the ten newest releases and groups older ones by minor version (53,000 px → 12,000 px tall) and is in the top navigation; the docs index has a jump list. Benchmark charts print every bar's value and are one tab stop each. The quick start has the install tabs and labelled output that matches what rws prints. Light-theme code passes 4.5:1, header and footer links are 40 px tall, the header no longer shows text through it, anchored headings clear it,theme-colorfollows the theme and long code lines wrap on phones. rws trust --printandrws untrustonly read: they no longer create a local CA when there is none.
18.36.2 — 2026-11-15
No code changes: a docs and website release.
Changed
- rws8.tech. The home page says what rws replaces and where it isn't the best fit, shows the newest version in its terminal and has an admin UI and Traffic tile; benchmark numbers carry their date and version; the comparison adds Traefik, axum and actix-web.
- Docs. Gateway API conformance is stated one way everywhere (passes the v1.7.0 suite in CI); the proxy overview, roadmap and environment variables no longer call shipped features planned; hot reload lists routes and upstreams. Changelog links to docs pages skip the redirect.
18.36.1 — 2026-11-14
Added
- Traffic: referrer spam.
[traffic] ignore_referrerslists referring sites that only send fake visits (a domain covers its subdomains): their visits count as direct and they never show among the referrers. Follows config reloads. - Traffic: outbound clicks. With
script = true, clicks on links to other sites (middle clicks too) are reported as the eventoutboundwith{to: "<host>"};goals = ["event:outbound"]counts them.
18.36.0 — 2026-11-13
Added
- Gateway API v1.7.0. The conformance suite and CRDs move to v1.7.0,
and rws claims the features that became standard there:
HTTPRouteRetryCodesandHTTPRouteRetryConnectionError(retries were already honoured),HTTPRouteBackendURLRewrite(URLRewriteon abackendRef),GRPCRouteRequestHeaderModifier,GatewayRouteHostnameIntersectionPrecedenceandTLSRouteModeMixed—TerminateandPassthroughTLS listeners on one port, chosen by SNI (they were refused withProtocolConflictbefore). - Gateway API experimental features (with the experimental CRDs and
RWS_CONFIG_GATEWAY_API_EXPERIMENTAL/ HelmgatewayAPI.experimental): listener filters withExternalAuthover HTTP and over Envoy'sext_authzgRPC, run before route selection; address routability (Cluster, theAddressesAssignedcondition); ClusterTrustBundle CA references in BackendTLSPolicies and client-certificate validation; destination port matching. CI runs the suite on the experimental channel. - Gateway API: BackendTLSPolicy for GRPCRoute and terminated TLSRoute (v1.7 core tests): gRPC backends under a policy are reached over HTTP/2 on TLS (they were sent HTTP/1.1), and a TLSRoute a listener terminates is encrypted again to a covered backend (it went in the clear).
- Gateway API mesh profile, routing only (
RWS_CONFIG_GATEWAY_API_MESH,RWS_CONFIG_GATEWAY_API_MODE=mesh-sidecar): HTTPRoutes and GRPCRoutes attached to Services route pod-to-pod traffic through an rws sidecar, by the destination's ClusterIP and port; consumer routes; status on Service parents; the controller serves sidecars their configuration and injects them (mutating webhook, HelmgatewayAPI.mesh.*; init imageghcr.io/bohdaq/rws-mesh-init, built per release). Passes the v1.7.0 MESH-HTTP and MESH-GRPC profiles. No mTLS. Service mesh.
Fixed
- Gateway API: other controllers' conditions survive rws's status writes
on Gateways and listeners (domain-qualified types), and Gateway and
ListenerSet status is written with the
resourceVersion. - Gateway API retries reach another endpoint. A retry after a refused
connection went to the same endpoint of a two-endpoint backend every
time (one counter drawn twice per attempt); endpoints now have their own
round robin (
HTTPRouteRetryConnectionError). - HTTP/2 upstream pool: connections to one address made for different TLS server names are no longer shared.
Changed
- Traffic: the site list shows sites. With sites configured,
www.<site>counts as<site>and every otherHost(addresses,localhost, none, names no route serves,[traffic] hide_hosts) as one Unknown hosts entry; saved counts of such names move there at start. A link fromwww.<site>to<site>is no longer a referral.
18.35.1 — 2026-11-11
Fixed
- The Linux musl binaries build again. 18.35.0's
x86_64andaarch64musl builds failed (cargo-auditable'scargo metadata --features serdestopped atrws-k8s, which had an optionalserdedependency but no such feature), so 18.35.0 has no musl binaries, Docker image, Homebrew formula, packages or chart.rws-k8snow has aserdefeature, and CI runs every feature throughcargo metadata. - Nix package: nixpkgs' Rust builds now link aws-lc and zstd from the system; the expression lists them.
18.35.0 — 2026-11-10
Added
-
Traffic: apps and extensions are their own group. Native apps and browser extensions that call the server never load a page's assets, so they used to count as bots. They're now Apps: named by
[traffic] apps("HITOP=HITOP/"matches aUser-Agenttoken and reads the version after it;"HITOP=chrome-extension://<id>"an extension'sOrigin) or by platform (Apple'sCFNetwork/NetworkingExtension, Android'sDalvik, Electron, extension origins). Apps report events withPOST /_rws/e({"app","v","p","n"}; configured apps only, any origin, 500 a client a day). The page's Apps view shows users by app and platform, versions and events. Referrals from app stores are their own channel, App stores. -
Traffic: your own visits are counted apart. A client that makes a successful admin API call (the admin UI, signed in), comes from
[traffic] owner_networks, or holds the owner cookie (/_rws/me?k=<key>, links on the page and fromGET /traffic/owner) is the owner's from then on, on every site; the page shows how many of your page views it left out. -
Traffic: how sure the people count is. Verified (ran the script), Likely (loaded assets), Page only and Server networks (counted as bots) under the key numbers.
-
Traffic: a Visitors tab. The last visits, newest first: country, device, channel, referring site and campaign, the pages in order, events, verified, the visit number that day. Up to 300 kept across days, with no address,
User-Agentor visitor key. -
Traffic: landing pages by source, downloads, probes and crawlers. The first page of visits from outside per channel; installers, packages, archives and
install.shfetched in full, by who fetched them; the paths scanners asked for and their country and network ([traffic] probe_addresses = trueadds the address); each named crawler's pages and 404s and the paths that 404 for them. -
Traffic: request goals.
goals = ["req:/api/proxy"]counts the sessions that made that request (any method, not only a page view). -
Traffic: browsers from hosting networks are bots. A browser
User-Agentfrom AWS, Google Cloud, Azure, OVHcloud, Hetzner, DigitalOcean or another cloud/server host (a link scanner, preview or headless crawler — they load assets and even run the script) now counts as a bot of kindhosting, named after the provider, not as a person. The networks are a ~60 KB table built from DB-IP's ASN Lite (ci/gen_hosting.py); consumer VPN and CDN egress is left out.[traffic] hosting_networks = falseturns it off. -
starters/operator: a Kubernetes operator — aGreetingcustom resource, a controller (owned ConfigMap, status, finalizer, leader election), validating and mutating webhooks,--manifests, a Dockerfile;ci/e2e/operator.shdeploys it into kind (CI jobkubernetes) and checks the API server calls its webhooks over TLS. -
WebhookCertificate::shared(one certificate for all replicas, in a Secret),to_secret/from_secret;k8s::client::offline(). -
Health checks (
health):health::readiness/liveness/startup(andregister_async,database(name, pool)) register checks that/readyz,/livez(/healthz) and the new/startupzrun — concurrently, with a timeout, off the event loop;?verboselists each check. Without checks/healthzand/readyzanswer as before. The Helm chart has an optionalstartupProbe. -
Kubernetes framework (
k8sfeature, new craterws-k8s,spec/K8S_FRAMEWORK.md), on kube-rs:k8s::client,ConfigWatch(ConfigMaps/Secrets kept current,apply_to_env),k8s://ns/name#keysecrets, service discovery from EndpointSlices into aBackendPool, and a publicLeaderElector.- Operators:
Controller(reconcile, owns, finalizers, error backoff),Operator(several controllers, leader election, readiness check,rws_controller_*metrics),Context(patch_status,apply_owned,event). - Webhooks: validating, mutating (JSON patch computed) and conversion, as
an rws app;
WebhookCertificate(CA + serving cert,patch_ca_bundle). - Manifests from the code: CRDs, RBAC (rules merged;
Operator::rules), webhook configurations,--manifests. testing::TestCluster: tests against a real API server (RWS_TEST_KUBECONFIG), a namespace per test; CI jobkubernetesruns them on kind.
-
rws gen deploy --image <image>:deploy/k8s/with a Deployment wired to the probes and graceful shutdown, Service, PDB, HPA, ServiceAccount and kustomization. -
Graceful drain: after SIGTERM's delay the async servers stop accepting, then wait up to
shutdown_timeout_secs(RWS_CONFIG_SHUTDOWN_TIMEOUT_SECS, default 25) for handlers still running; before, those were cut off when the process exited.
Added
-
Web layer (roadmap #94,
spec/AGENT_FIRST_FRAMEWORK.md):- Route groups and guards:
app.group("/admin", |g| g.guard(signed_in).wrap(layer).get(…))onAppWithStateandAsyncAppWithState(async groups: guards, no per-group middleware); groups nest, guards run outer first. - Resources:
app.resource("/posts", |r| r.index(…).show(…)…)— the seven conventional routes (newbefore{id},updateon PUT and PATCH), each namedposts.<action>;extrafor more. - Named routes:
.name("post")after a route,router::url_for(name, params). - Flash messages (
flash):Redirect::to(path).notice(…)(303),Flash(also a handler argument),FlashLayerclears it once shown. - View helpers: the
url_for,viteandvite_assettemplate functions andtemplate::page_context(request)(flash,csrf_field, path). Theterafeature now turns onserde. - Vite manifest helper (
vite,serde): tags for an entry from.vite/manifest.jsonor the dev server (VITE_DEV_SERVER). - Channels (
channels::Hub): named topics pushed to SSE and WebSocket clients. - Attachments on models (
attachment, anystorage-*feature): a file in aStoragebackend as oneTEXTcolumn, from a multipart upload withAttachment::from_multipart.
- Route groups and guards:
-
Sign-up and login (
auth_flows, roadmap #92;crypto+mailer+serde):AuthFlows, a middleware with sign-up, login, logout, password reset and email confirmation as JSON or HTML forms (built-in pages or your Tera templates); signed stateless sessions (a password change ends them) and single-use reset links; rate limits per IP;CurrentUser,signed_inandsigned_in_or_redirect;UserStorewithMemoryUserStoreandDbUserStore(rws_users). -
Jobs, mail and events (roadmap #93):
PersistentJobQueue:enqueue_with(type, payload, EnqueueOptions)—run_at/run_in, namedqueues (queues(&[…])limits a process),priority,unique(key); the dead-letter list (failed_jobs,retry,delete,on_dead,jobs);schedule(name, cron, type, payload)enqueues on a cron schedule once per due time across replicas (rws_job_schedules).CronSchedule::next_after.- Mail:
Mail(anEmailwithMailAttachments, sent asmultipart/mixedbyMailer::send_mail); theDelivertrait andTestMailbox;deliver_lateron aJobQueueandMail::enqueue+register_deliveryon aPersistentJobQueue;EmailBuilder::renderfrom<name>.txt/.htmltemplates (tera);MailPreviewsat/_mail. events::EventBus: typed in-process events, forwarded to MCP notifications or channel topics.
-
Defaults (roadmap #95):
RWS_ENVprofiles:RwsEnv::shows_error_details()(dev, test) andreloads_templates()(dev);template::renderre-reads templates before each render in dev.error_pages::ErrorPages: panics and app errors as a page with the message, location, request and backtrace (or problem details withlocation/backtrace) in dev and test, a bare500in prod.cache::ValueCache:fetch_or/try_fetch_or/fetch_or_asyncwith a TTL per entry.- Container lifecycle: the
Lifecycletrait,register_managed,on_start/on_stop,start/stop.
-
ORM: nested eager loading —
with_nested(relation, |n| n.with(…))onQueryBuilder/EagerQuery, read withLoaded::related_loaded(one query per relation per level);rws gen migration <name> --from-models(generator::plan_model_migration) writes the additive migration from the#[derive(Model)]structs to the database (CREATE TABLE,ADD COLUMN; anything else is a note). -
Model admin (
model_admin::ModelAdmin, roadmap #109; amodel-*feature): pages to list, search, show, create, edit and delete rows of registered tables, read from the live schema; denied unlessallowsays otherwise. -
AsyncAppWithState::wrap, asAppWithState::wrap. -
AuthFlows::on_signup, andstarters/fullstacknow has accounts (/auth, a guarded/api/account), a welcome email sent by a job,FlashLayer,ErrorPagesand mail previews in dev.
Fixed
-
Traffic: the admin UI's own page views. Viewing the Traffic page through a route that proxies the admin API counted its owner as a visitor (
rws8.tech/admin/was among the site's top pages); the owner is now apart (above). -
Traffic: the site picker. The first 16
Hostnames seen took every slot, so raw IPs,(none)and mail names crowded out real sites, which then counted asother. Every site a[[route]]matches byhostnow gets its own counts (read at start and on reload) and is listed first, under Sites, then other names seen. -
Traffic: picking a site shows only that site. Visitors, AI agents, bots and referring sites were all sites' together; pages matched by prefix (
example.comalso tookexample.com.evil) and included the shared(other)row. Days counted before the upgrade keep their all-site lists, shown under All sites. -
/readyzof library apps answered503for good: only therwsbinary marked the server ready.Server::run,run_plainandrun_tlsnow do as they start serving. -
k8s::manifests::to_yamloutput crashedkubectl apply: a stream starting with{is read as JSON, and kubectl panics when a document over 2 KiB (a CRD) is followed by---. Each document now starts with---. -
The Gateway API controller's leader election is
rws_k8s'sLeaderElector(theleaderfeature of rws-k8s); its behaviour and API are unchanged. -
PersistentJobQueueon PostgreSQL and MySQL: its SQL used?placeholders (PostgreSQL wants$1…) and aTEXTprimary key (MySQL refuses one), so it only worked on SQLite. CI now runs it on all three.
Changed
- Admin Traffic page: world map is now
@lit-material/world-map: one tab stop, the arrow keys read countries highest first and Enter picks one (again clears the filter), a legend for the shading, countries too small to draw (Singapore, Malta…) listed under the map, and a screen-reader table. The shapes it ships are 12 kB gzipped instead of 27 kB;ci/gen_world_map.pyis gone.
18.34.1 — 2026-11-06
Docs and website only; no code changes.
Changed
- rws vs nginx vs Caddy: a new comparison page in the reference section, with the nginx and Caddy facts checked against their docs (sources on the page).
- Answer-first openings on the home page, Quick start, Automatic HTTPS and the proxy overview, plus new home page FAQ entries.
18.34.0 — 2026-11-06
Added
.mdis served astext/markdown(and compressed): Markdown copies of pages for AI agents no longer download asapplication/octet-stream.- rws8.tech for search engines and AI answers:
robots.txt(AI crawlers explicitly welcome) andsitemap.xml(with each docs page's last change from git) are generated; docs pages carryTechArticleandBreadcrumbListstructured data, a visible "Last updated" date and a Markdown copy (/docs/<page>.md, also linked from the page); the home page addsOrganizationandWebSite; every page hasog:type,og:urland a Twitter card;/favicon.icoexists.llms.txtlinks the Markdown copies under/docs/(it linked old paths that redirected).
Fixed
- The home page (
/→./index.html) gets the staticCache-Control(static_cache_control, defaultno-cache) like every other static file, not the dynamicno-store, which kept browsers from caching it and out of their back/forward cache. - A config
staticroute answers a miss with its root's404.html(status 404) when there is one, as the default static server does; it sent an empty body.
18.33.0 — 2026-11-05
Added
- Traffic page: Humans / AI agents / Bots / All: a switch in the top bar. AI agents and Bots get their own numbers (with the change from the period before), chart and lists — agents with what they're for and the pages they read; bots by kind and name, and 404s — and All charts the three groups together with their share of requests. Replaces the AI & bots tab.
- Traffic page: world map of people's countries (Natural Earth 1:110m,
public domain, generated by
ci/gen_world_map.pyinto the page; no outside requests); clicking a country filters by it.
Fixed
- Traffic page: a long page name no longer pushes a card's numbers into the next card; the site picker matches the other controls.
Older releases
18.32 18.32.0 — 2026-11-05
18.32.0 — 2026-11-05
Changed
- The admin UI's Traffic page, redesigned: a sticky bar (Today / 7 days / 30 days / a custom range, site, compare with the period before, people online), key numbers that choose what the chart shows, cards of top pages, sources, countries and devices, and tabs for Pages, Sources, Audience, Behaviour and AI & bots instead of one long page. Click a row to filter by it (any dimension with the traffic database). Page names drop the site when there's one.
GET /admin/api/v1/traffictakesfrom/todays, and its answer gainspagesper bucket,previous_seriesanddays. Views over two days now cover whole UTC days (a "week" is today and the six days before), so per-day counts line up with the period; the site list leaves out hosts with no counted traffic.- rws8.tech loads the first-party traffic script on every page.
18.31 18.31.0 — 2026-11-05
18.31.0 — 2026-11-05
Added
-
Bundled traffic tables refreshed: AI agents and crawlers (
ci/gen_bot_lists.py --update) and DB-IP Lite countries 2026-11. -
Traffic page: sources and audience (
spec/TRAFFIC_ANALYTICS.md, tranche 1): how people arrived (direct, search, social, AI assistants, other sites, UTM campaigns withutm_source/utm_medium/utm_campaigntables) and who they are (country, browser, operating system, device class), each person counted once a day — in the admin UI,GET /admin/api/v1/traffic(channels,countries,browsers,os,devices,utm_*,geo_source) and the saved file. Countries come from a DB-IP Lite table built in (new default featuregeo, ~700 KB;ci/gen_geo.py;[traffic] geo_dbfor a newer one); the lookup stays on the server and no address is kept. Chromium client hints are preferred to theUser-Agent. No cookies or browser storage. Same per-request cost as before (A/B ~165 ns). Fuzz targettraffic_geo. -
Traffic page: sessions (tranche 2): sessions (page views ≤ 30 minutes apart), bounce rate, session length, pages per session — with the change from the previous period — and entry and exit pages;
GET /trafficgainssessions,previous_sessions,entry_pages,exit_pages. Sources now count once per session, from its first page view. Older saved files load unchanged. -
Traffic page: right now (tranche 3): people on the site in the last 5 minutes, page views per minute for the last 30, the pages being read and where the readers are —
GET /admin/api/v1/traffic/live, MCPtraffic_summary {"live": true}, a "Right now" tile on the Traffic page (which now refreshes every 10 s). Kept in memory only (≤ 4096 recent page views per shard). -
Traffic page: the optional first-party script (tranche 4):
[traffic] script = truemakes rws serve/_rws/t.js(~1.6 KB, no cookie or browser storage) and take its reports at/_rws/t(same origin, ≤ 2 KB, only for visitors counted as people, ≤ 500 per session). New Behaviour section: time on page, scroll depth, screen sizes, single-page-app route changes (counted as page views),rws.track(name, props)events, and goals ([traffic] goals: paths,prefix*,event:<name>) with conversions per session.TrafficScriptLayeris wrapped into the binary's static and proxy apps and passes other requests through (proxy routes keep the async forwarder)./_rws/is reserved. -
Traffic database (PostgreSQL, opt-in) (tranche 5):
[traffic] database_url_envnames the variable holding apostgres://URL; rws createsrws_traffic_pageviewsandrws_traffic_reportsand writes every person's page view and script report there in batches (no IP or User-Agent; bounded queue, dropped rather than blocking).GET /admin/api/v1/traffic/query(and MCPtraffic_summarywithfrom/to) answers any date range and filter combination; the Traffic page gets an Explore section. Release binaries now includemodel-postgres(sqlx), except the FIPS build. -
ORM, part 2 (roadmap #90):
- Eager loading:
Post::query(&pool).with(Post::comments()).with(Post::author()).fetch_all()loads each relation for the whole result set in one more query (WHERE fk IN (…), 500 keys per query), not one per row. Amodel::Relation<O, R>describes it —has_many(fk),has_one(fk),belongs_to(fk),belongs_to_many(join, owner_key, related_key)— and loads one owner's (load) or many owners' (load_for) rows too.with()returns anEagerQuerywhosefetch_all/fetch_one/paginateanswerLoaded<T>(derefs to the model;related(&rel),one(&rel),take,is_loaded). Soft-deleted related rows are left out. See Eager loading. - Many-to-many:
BelongsToMany<R>—load,ids,attach,detach,detach_all,sync(answersSyncChanges), through a join table. - Scopes:
QueryBuilder::scope(f)applies a reusable query function;where_in,where_null,where_not_null. See Scopes. - Seeds in Rust:
model::Seeders(add(name, |pool| async move { … }), or theSeedertrait) run afterseeds/*.sqlbyDbPool::seed_with(dir, &seeders); factories make the rows.db_cli::run_with_seedersgives an app's own binarydb seedwith them. See Seeds in Rust. - Read replicas:
DbPool::with_replicas(primary, replicas)(orRWS_DB_REPLICA_URLSwithDbPool::from_env) sendsquery*— so the query builder's and repository's reads and relation loads — to the replicas in turn, and writes, transactions, migrations, seeds,saveandschemato the primary;primary(),replica(),replicas(),close().DbPoolhas a new variant,Replicated: code matching on its variants needs an arm for it (close()replaces the usual match to close a pool). See Read replicas. - The schema as data:
DbPool::schema()→DbSchema(tables, columns with type / nullability / default, primary key, indexes, foreign keys) on SQLite, PostgreSQL and MySQL,to_json();rws db schema [--json], and the dev MCP server'sdb_schemanow lists keys, indexes and foreign keys too. See The schema as data. rws gen model … --timestamps --soft-delete(and thegen_modeltool'stimestamps/soft_delete):#[timestamps]withcreated_at/updated_at,#[soft_delete]withdeleted_at, the columns in the migration;Generate::Modelhas the two new fields.
- Eager loading:
18.30 18.30.0 — 2026-11-04
18.30.0 — 2026-11-04
Added
- SPA fallback per path prefix:
spa_fallback_routes = ["/cloud=cloud/index.html"](RWS_CONFIG_SPA_FALLBACK_ROUTES) gives each single-page app on a server its own fallback file, so a site can host apps under/cloudor/adminwhile its other misses stay404. Longest prefix wins;spa_fallbackstill covers paths under no prefix;rws --checkreports missing files and malformed entries. See Several apps on one server. - ORM, part 1 (roadmap #90; rws-macros 17.31.0): see
Keys, timestamps, soft delete and locking.
- Keys beyond
i64:ModelRepository<T, ID>implementsRepositoryfori32,Stringandmodel::Uuidtoo (PrimaryKey). For a key that isn't auto-increment,saveinserts when the key isn't in the table and updates otherwise; aUuid::NILkey gets a freshUuid::now_v7();repo.insert(&entity)always inserts.T::repository(&pool)is keyed by the key's type forString/Uuidkeys (stilli64for integers).Uuidis rws's own (v4, v7, parse,serde), stored as text. #[timestamps]:savewritescreated_at(insert only) andupdated_at(model::Timestamp, UTC, microseconds) —TEXTon SQLite,TIMESTAMPTZon PostgreSQL,DATETIME(6)on MySQL.#[soft_delete](deleted_at: Option<Timestamp>):delete_by_idandQueryBuilder::deleteset it; the repository, the query builder and relations skip such rows unlesswith_deleted()/only_deleted();restore,force_delete_by_id/force_delete,find_by_id_with_deleted.#[version]: optimistic locking —saveof a stale copy changes nothing and fails withDbErrorKind::StaleVersion(DbError::kind(),is_stale_version(); alsoNotFound).DbPool::seed(dir)andDbPool::connect(url);FromColumn for Value.- PostgreSQL
TIMESTAMPTZ/TIMESTAMP/DATE/UUIDand MySQLDATETIME/TIMESTAMP/DATEcolumns read as text (they wereNULL).
- Keys beyond
rws db migrate|rollback [N]|status|seed(roadmap #91): the project's migrations (rws.app.toml's path) and seeds (seeds/beside them) from the command line, on--database-url,DATABASE_URLorRWS_DB_*;--json(thestatusJSON is the dev MCP server'smigrationsanswer), exit codes 0/1/2. Needs arwsbuilt with amodel-*feature. Seerws db.- CI runs the model,
TestDbandrws dbtests on PostgreSQL 16 and MySQL 8.4 (jobmodel-databases), as well as SQLite. - rws-macros 17.31.0 must be published before rust-web-server.
Fixed
- The model layer on PostgreSQL and MySQL, found by running its tests
there for the first time:
INTEGER/SMALLINT/REALcolumns read asNULLon PostgreSQL (onlyBIGINT/DOUBLE PRECISIONdecoded), and so did anINSERT … RETURNINGof aSERIALkey;saveof aNonefield failed on PostgreSQL ("column is of type integer but expression is of type text" — NULLs are now written as literals);QueryBuilder::count(and sopaginate) afterorder_byfailed on PostgreSQL (theORDER BYis left out); and migrations failed on MySQL, which can't key the_schema_migrationstable'sTEXTcolumn (nowVARCHAR(255); existing tables keep working). On SQLite a column declared with a type sqlx doesn't read as text (DATETIME,DATE) is read as it is stored rather than asNULL.saveof a missing row with a non-zero key is aDbErrorKind::NotFounderror instead of "updated row not found".
18.29 18.29.0 — 2026-11-04
18.29.0 — 2026-11-04
Added
-
Test helpers (roadmap #89), all in
test_client(nothing on the request path changes):client.websocket(path).connect()→TestWebSocket: runs a route'sWebSocket::upgradehandler over an in-memory duplex —send_text,send_binary,recv,recv_text,close(masking, pings, fragments and the closing handshake handled); a refused upgrade is theErrresponse. See WebSocket and SSE in tests.response.sse()/response.sse_events(n, timeout)read atext/event-streambody, streamed or buffered, intoSseFrames (event,data,id,retry);SseParseris the bounded parser underneath (fuzz targetsse_stream).TestResponsekeeps a streamed body (is_streamed,take_stream) and isDebug.assert_openapi_snapshot(&client, "tests/snapshots/openapi.json")andassert_json_snapshot: normalized JSON (sorted keys) compared with a committed file, a line diff on a mismatch;RWS_UPDATE_SNAPSHOTS=1writes it. See OpenAPI snapshots.TestDb(model-*features):TestDb::sqlite().migrations("migrations").awaitis a fresh in-memory database per test;TestDb::postgres(url)/mysql(url)(and_from_env, readingRWS_TEST_POSTGRES_URL/RWS_TEST_MYSQL_URLand skipping when unset) migrate once, then pin the pool to one connection inside a transaction that is never committed.#[derive(Factory)](rws-macros 17.30.0) beside#[derive(Model)]:User::factory().with(|u| …).build()/.create(&pool).await/*_many(n), with per-type defaults (name-3,email-3@example.com,0,false,None). See Test databases and factories.TestRequest::send_async().awaitforApp::with_async_stateapps: awaits the handler instead of blocking the test's thread (senddoes), for pools made on a single-threaded test runtime.
-
rws-macros 17.30.0 must be published before rust-web-server.
-
rws gen model|route|migration|test(roadmap #88): code generators for a project in the conventional layout (rws.app.toml).gen model Post title:String …writes a#[derive(Model)]type (idauto-increment, a test — with SQLite a round trip through the migrations) andmigrations/NNNN_create_posts.sql+.down.sqlfor SQLite, PostgreSQL or MySQL (--db, else themodel-*feature inCargo.toml, which is added when missing);gen route poststyped handlers (#[get]…, list, show, create, update, remove) withregister(app), registered inapp();gen migration <name>an empty up/down pair;gen test postsTestClienttests for those routes. Output is pinned to the release's API — CI generates into every starter and runs the generated tests. Nothing is overwritten: a file in the way is a conflict shown as a unified diff (exit 1), so a second run changes nothing;--dry-run,--json,--dir. Also the dev MCP endpoint'sgen_model,gen_route,gen_migration,gen_testtools (dev_mcp::GEN_TOOLS; left out by.read_only();dry_run) and therust_web_server::generatormodule. See Generators.
Fixed
-
A config change before the server was up ended the process. Fleet's first pull, the config watcher and the admin API ask for a reload by raising
SIGHUP; one that came after startup marked the server ready but before the accept loop had installed its handler hit the signal's default action.config_reload::request_reloadnow reloads in place until a handler is installed (seen inci/e2e/fleet.sh's S3 step). -
App::with_async_statehandlers lost theirDbPoolconnection after every request. Each request's handler ran on a tokio runtime made for it and dropped afterwards (async_bridge::block_on_isolated); sqlx gives a connection back to its pool from a task spawned on that runtime, which never ran, so the connection was closed: a reconnect per request for PostgreSQL/MySQL, andDbPool::memory()lost its database between requests. This was every request to an async route — the async servers never awaited the handler directly — andMcpServer::async_toolcalls. Handlers now run on long-lived runtimes: the async servers await them throughApplication::execute_async(now offered for matching routes) on the connection's runtime, or on a process-widerws-asyncruntime under per-core runtimes; synchronous callers (behind a middleware layer, the HTTP/1.1-only build,TestClient::send) wait while it runs onrws-async. Also no thread and runtime built per request, and requests no async route matches go to the fallbackAppwithout any runtime. The caller's span,Identityand early-hints destination stay current in the handler. See Where handlers run. -
MCP:
tools/callread the tool's name from its arguments when an argument was callednameand the client sentargumentsbeforename(as clients that sort keys do): the call went to the wrong tool or failed with "Unknown tool". The name and the arguments are nowparams' own members. -
Proxy: no 502 for a POST after a backend closed an idle connection. The upstream pools kept idle connections for 60 s, while an rws backend closes them after 30 s; a non-idempotent request on such a connection could not be retried and got a 502 (seen with Stripe webhooks behind a config-file route). A pooled connection is now checked before reuse (a non-blocking peek, plain and TLS, sync and async forwarders) and skipped when the backend has closed it, and the pools keep idle connections 25 s. A request that the backend drops after receiving it is still not replayed unless idempotent.
18.28 18.28.0 — 2026-11-04
18.28.0 — 2026-11-04
Added
-
app.dev_mcp()(roadmap #85): an MCP endpoint a coding agent can use to inspect the app it is working on —routes(method, pattern and the middleware stack around them),config(RWS_ENV, features and everyRWS_*/OTEL_*/MCP_*setting, secrets and URL passwords hidden),recent_requests,recent_errors, and with amodel-*featuredb_schema(SQLite, PostgreSQL, MySQL) andmigrations/migrations_run/migrations_rollback_last. On everyApplicationthroughrust_web_server::dev_mcp::DevMcpExt;DevToolschooses the tools (.database,.migrations,.with_ops,.read_only,.token,.at). Mounted only withRWS_ENV=dev(then without authentication) or a bearer token (MCP_TOKEN); otherwise the app is served alone. See Let a coding agent inspect your app. -
RWS_ENV(dev,test,prod— the default) andentry_point::RwsEnv. -
The
rwsbinary's 25 MCP operations tools moved into the library asdev_mcp::ops_tools(the binary uses it; names, order and behaviour unchanged), withdev_mcp::OPS_WRITE_TOOLS. -
Application::registered_routes()/Application::middleware_names()andMiddleware::layer_name(), default methods that let tools describe an app;WithMiddleware,McpServerandTimeoutLayerforward them. -
Conventional app layout and
rws.app.toml(roadmap #87): one layout for rws applications —src/main.rs(wiring only),src/lib.rs(app()),src/routes/,src/models/,src/jobs/,migrations/,templates/,tests/,static/— and a manifest at the project root naming the app and any path that differs (every key optional; absent means conventional).app_manifest::AppManifest(load(dir),parse,layout(dir)),AppPaths,LayoutEntry,EntryKind,ManifestError(line-numbered, never a panic; unknown keys are warnings). Fuzz targetapp_manifest. See Project layout. -
dev_mcptoolslayout(the manifest and which conventional paths exist, with their files) andmodels(model-*): the types named withDevTools::model::<T>()— table, columns, primary key — compared with the database's tables when one is configured (missing_columns,unmapped_columns).DevTools::app_dir(dir)sets the project root.model::ModelInfo::of::<T>()describes aModeltype. -
Starters on the layout:
starters/api,mcpandfullstacksplit intomain.rs+lib.rs+routes/(tools/for MCP) /models/+tests/, ship anrws.app.toml, use typed handlers (#[get]+.route(f); errors as problem details), and mountdev_mcpunderRWS_ENV=dev. Each has atests/dev_mcp.rsthat calls every dev MCP tool it lists;ci/e2e/starters.shruns them, fills{{crate_name}}, patchesrws-macros, and fails on stray{{/{%text cargo-generate would misread. The starters now ask forrust-web-server18.28;fullstack's migration is0001_create_notes.sqlwith a.down.sql. -
Logs for security monitoring (#102). All opt-in; with none of it set the access log is byte for byte what it was.
- IP anonymisation:
access_log_anonymize_ip = "truncate"writes client addresses as their IPv4 /24 or IPv6 /48,"hash"as a keyed HMAC-SHA256 pseudonym (access_log_ip_hash_secret) — in JSON and combined lines (also for addresses fromX-Forwarded-For), OTLP log records andrecent_requests. - Redaction:
log_redact_query = ["token", "api_key"]logs those query values asREDACTEDin paths andReferers;log_redact_headersdoes the same for header values.Authorization,Proxy-Authorization,CookieandSet-Cookieare never logged (the access log writes onlyHost,User-AgentandReferer;Log::request_responsenow shows them asREDACTED). - Syslog:
access_log_syslog = "udp://host:514",tcp://…(RFC 6587 octet counting) orunix:///dev/logsends every line as an RFC 5424 message (facilityaccess_log_syslog_facility, defaultlocal0), from a background thread. - OTLP logs: with
OTEL_LOGS_EXPORTER=otlpaccess-log records go to the collector's/v1/logs(OTLP/HTTP JSON), carrying the request's trace and span ids when it was traced; batched per thread and sent off the request path (otel::logs).ci/e2e/otlp.shchecks them. - Tamper-evident audit log: lines appended to
[admin] audit_logcarryprev(SHA-256 of the line before) andhash;GET /admin/api/v1/audit/verifyandrws ctl audit --verify [FILE]report the first edited, removed or inserted entry. Files from before keep working (their lines start the chain). rws --checkvalidates the new settings.
- IP anonymisation:
-
Compile-checked routes (#86).
#[get("/posts/{id}")]& co. on a function whose arguments are extractors —Path<T>,Query<T>,Form<T>(serde),Json<T>,State<S>or&S,Body,BodyText,RequestHeaders,&Request,&ConnectionInfo, anyFromRequesttype — and whose return type is anythingIntoResponsegenerates the handler adapter: register it with.route(show_post)onAppWithState,RouterorAsyncAppWithState(which also takesasync fnhandlers). The route's parameters are checked against thePathargument at compile time (a wrong name, a tuple of the wrong arity, a parameter nobody takes, a#[derive(FromPath)]struct whose fields don't match). A failed extraction answers with its rejection (400/415/422, problem details). Classic handlers keep the doc-comment-only behaviour. New: modulehandler(Handler,AsyncHandler,RouteSpec,FromRequestParts,RequestParts,Path,FromPath,State,Query,Form,HandlerFuture) and#[derive(FromPath)]. See Routing. rws-macros 17.29.0 must be published before rust-web-server. -
Duplicate and shadowed routes are reported.
route_conflicts()onRouter,AppWithStateandAsyncAppWithStatelists routes that never run because an earlier one with the same method matches every path they do (/users/:idand/users/{uid};/users/:idbefore/users/me); each is printed once to stderr when it's registered. Dispatch doesn't change. -
IntoResponseforResult<T, E>,String,&'static str,Json<T>and(&StatusCodeReasonPhrase, T). -
Feature presets (#96):
web(templates, cookies and CSRF, password hashing, SQLite ORM, jobs, mail),api(serde, macros, OpenAPI, JWT auth, SQLite ORM, jobs),proxy(HTTP/3, ACME, compression, route auth, regex rewrites, secret references) andfull(every feature butfips,pkcs11,http1andmimalloc). They only turn on other features; contents and clean build times on Installation. -
docs.rs shows every feature's items (#96), each labelled with the features it needs (
[package.metadata.docs.rs]with--cfg docsrsanddoc_cfg, in the facade and every crate undercrates/). -
Database TLS:
RWS_DB_SSL_MODE(disable,prefer,require,verify-ca,verify-full),RWS_DB_SSL_ROOT_CERTandRWS_DB_SSL_CLIENT_CERT/_KEY, read byDbPool::from_env()(and the SQL authorization store); in codeDbTls/DbSslModeandDbPool::new_with_tls. A managed PostgreSQL or MySQL with its own CA can now be verified; before, rws could only connect without checking the certificate.DbPool::newkeepsprefer. -
http_client::Client::ca_file(path)trusts a private CA instead of the public roots;S3Storage::with_ca_fileandRWS_S3_CA_FILEuse it for an S3 endpoint with a private certificate.
Fixed
-
Config-file routes with
[route.middleware.authz]take the authorizer of the compile that builds them. They used to read the process-wide one back after setting it, so two configs compiled at once (parallel tests) could hand a route the other config's authorizer, or none, so it answered503. This was the cause of a flakyserver_tests::authztest. -
PostgreSQL and MySQL pools panicked at their first TLS connection (rustls: no process-level crypto provider) in an app that doesn't serve TLS itself, as behind a load balancer; rws now installs its provider first. The user and password are passed to the driver as they are, not in a URL, so
@,:,/and#in them work. -
Behind a load balancer that terminates TLS, the URLs rws builds for the client said
http://: the A2A agent card's interface (gateway routes andA2aServer),OidcAuth's redirect URI when none is configured, and its cookies had noSecure. They now take the scheme from a trusted proxy'sX-Forwarded-Proto(ip_filter::request_scheme).ForwardAuthLayersends that scheme and the client's address (not the load balancer's) asX-Forwarded-Proto/X-Forwarded-For. Found by the stage suite (S7.5). -
S3: an endpoint on a port other than the scheme's default (MinIO's
:9000) gotSignatureDoesNotMatchfor every request: the signedHostleft the port out, the one sent had it. -
FastCGI:
SCRIPT_FILENAMEandDOCUMENT_ROOTare the paths under the configuredroot, with symlinks left in (nginx's$document_root$fastcgi_script_name), not resolved. php-fpm in another container, with the same files mounted at the same path, answeredFile not found.for every script when symlink targets differed there, as in a Kubernetes ConfigMap volume. Found by the stage suite (S9.4). Symlinked deploy directories (current→releases/N) now show PHP thecurrentpath.
18.27 3 releases: 18.27.0 – 18.27.2
18.27.2 — 2026-11-03
Fixed
- Streamed proxy bodies ended only at the backend's read timeout. A
large (> 1 MB) upstream response with a
Content-Lengthwas read past its last byte on the backend's keep-alive connection until the read timeout: HTTP/2 and HTTP/3 clients got the whole body, thenRST_STREAM(INTERNAL_ERROR) 30 s later — Git LFS retried for ever — and HTTP/1.1 clients waited 30 s (18.27.1 hid it there). The body now ends at its length (a shorter one is an error), in both forwarders. A chunked upstream body over HTTP/1.1 is decoded and framed again, so it ends at the last chunk instead of the same timeout; its trailers are no longer passed on. - An HTTPS backend that stalled or failed mid-body ended a streamed body as
if complete; with a
Content-Lengththat is now an error.
18.27.1 — 2026-11-03
Fixed
- Large proxied downloads over HTTP/1.1 (an upstream
Content-Lengthover 1 MB, e.g. Git LFS objects behind rws). The HTTP/1.1 writer dropped the length and re-chunked the body in 8 KiB pieces of three writes each: 1.8 MB/s where HTTP/2 did 90 MB/s, and a backend that failed mid-body got a final chunk, so the client received a short body that looked complete. Now theContent-Lengthis kept and exactly that many bytes are copied; reads and writes are 64 KiB (one write per re-encoded chunk too); a read error or an early end closes the connection without ending the body.
18.27.0 — 2026-11-03
Added
- Helm chart:
configFile— therws.config.tomlas a value, mounted from a ConfigMap withRWS_CONFIG_FILEset (until now the chart had no way to give rws routes, upstreams or middleware);extraVolumes/extraVolumeMounts. Found by the stage end-to-end suite. ip_filter::client_ip(request, peer)— the client address an app should use (below).
Changed
- The client behind a trusted proxy. When the peer is in
trusted_proxies, the client address is the first untrusted one from the right ofX-Forwarded-For(elseForwarded: for=), as nginx'sreal_ip_recursive. The rate limits,allow_ips/deny_ips, blocklist, WAF IP rules,ip_hash, access and request logs, FastCGIREMOTE_ADDR, admin audit and Wasm plugin input use it; until now behind a load balancer they all saw the balancer (every client shared one rate-limit bucket). Breaking for an IP allowlist written against the balancer's address:client_ip = "peer"(RWS_CONFIG_CLIENT_IP) restores it. Found by the stage end-to-end suite. - A backend that doesn't answer within
read_timeout_ms(or connect in time) gets504 Gateway Timeoutinstead of502 Bad Gateway, as nginx answers;Proxy-Statusalready saidhttp_response_timeout. Found by the stage end-to-end suite. [cors]reaches[[route]]responses too, as documented ("every response"): an allowed origin's preflight is answered by rws, and a route's response gets the headers unless its backend sent its ownAccess-Control-Allow-Origin. Until now only static files had them. Found by the stage end-to-end suite.- Static-file ETags come from a hash of the file's bytes instead of its
modification time, so every replica gives the same ETag and
If-None-Matchgets a304from any of them (behind a load balancer it was 1 pod in 3). Worked out once per file version; files over 256 MiB keep the modification time. Cached ETags from before revalidate once with a200. Found by the stage end-to-end suite. - On SIGTERM rws keeps accepting for
shutdown_delay_secs(default 5,RWS_CONFIG_SHUTDOWN_DELAY_SECS) with/readyzalready503, then drains: a load balancer still sending to the pod in the moment after the stop got errors (a503in a rolling restart behind the kube-dc gateway).0restores the immediate drain; Ctrl+C has no delay. Found by the stage end-to-end suite. Forwardedbehind a proxy that sends onlyX-Forwarded-*(a TLS terminator, most load balancers) starts with its hops, the client's with theX-Forwarded-Proto/-Hostit reported: it said only this hop'sfor=<proxy>;proto=httpwhileX-Forwarded-Protosaidhttps. Found by the stage end-to-end suite./metricsonly for scrapers.GET /metricsanswers clients inmetrics_allow(RWS_CONFIG_METRICS_ALLOW; loopback and private ranges by default) and404s the rest: it was public, upstream names and backend addresses included."*"restores it. Found by the stage end-to-end suite.- Basic auth answers wrong credentials with
WWW-Authenticatetoo (only missing ones had it), so a browser asks again (RFC 9110 §11.6.1). Found by the stage end-to-end suite.
18.26 18.26.0 — 2026-11-03
18.26.0 — 2026-11-03
Changed
- rust-web-server is now a workspace of crates published together at one
version (
spec/WORKSPACE_SPLIT.md). Everyrust_web_server::…path is unchanged and the public API is identical — keep depending onrust-web-server; the other crates are internal:rws-base—core,ext,http,mime_type,null,symbol,url;rws-http— requests, responses, headers, ranges, bodies, JSON, extractors, compression, CORS, errors, settings;rws-server— the servers, TLS,App, routing, middleware, MCP, OpenAPI, SSO, sessions, metrics, OpenTelemetry, the HTTP client, the model layer;rws-proxy— proxy, config routes, admin API, cluster, fleet, WAF, LLM and A2A gateways, FastCGI, traffic insights;rws-acme,rws-storage,rws-tower,rws-wasm-plugin,rws-gateway-api— built only with the feature that enables each.
- ACME, the proxy, the WAF, the LLM gateway, traffic insights and templates plug into the server through registration hooks instead of being called from it.
- Contributors: a change in one layer rebuilds and retests that layer only
(an
mcpchange: 3 s to rebuild its tests, 21 s before).
18.25 18.25.0 — 2026-11-02
18.25.0 — 2026-11-02
Changed
-
CI checks the public API (
public APIjob,ci/public_api.sh) againstci/public-api.txt, so a release can't drop or change a public item by accident; additions update the listing in the same commit. -
PKCS#11 keys: a handshake's signature no longer stalls the worker it runs on — on the shared runtime the worker's other connections move to the rest of the pool while the token works (
block_in_place). Therwsbinary therefore keeps the shared runtime when a TLS key is apkcs11:URI andruntimeisn't set (per-core was the default since 18.0.0); an explicitruntime = "per-core"still wins, with a startup warning. -
One base64 decoder:
core::base64::Decoder(standard, URL-safe or either alphabet; optional whitespace; padding optional, concatenated padded segments allowed) replaces seven private decoders (JWT, PKCE, PEM, webhook secrets, Azure keys, etcd values, MCP content).Base64::decodewas quadratic — a 200 KB input took minutes — and is now linear;Base64::encodeno longer allocates per 3 bytes. Input that was never valid base64 (a lone trailing character, data after too much padding) is now refused everywhere instead of being decoded to whatever bits were left.
18.24 18.24.0 — 2026-11-01
18.24.0 — 2026-11-01
Changed
- Releases are gated (#83): the release workflow refuses a tag whose commit
isn't on
mainor a<major>.<minor>.xline or whose CI run isn't green; CI builds with--locked, lints the workflow files (actionlint) and checks the release's Windows features on Windows. The18.20.xLTS branch exists. - Proxied requests: client-sent forwarding headers are believed only from
trusted_proxies(#84). An incomingX-Forwarded-For/Proto/HostorForwardedis kept when the peer is loopback or in a private range (10/8, 172.16/12, 192.168/16, 100.64/10, fc00::/7) by default; from anyone else rws replaces them, so a client can't claimhttpsor another host to your app. Behind a public CDN (Cloudflare, Fastly…) list its ranges intrusted_proxies, or settrusted_proxies = "*"for the old behaviour.
Security
- Fleet config pull (#80): signatures now carry a serial (
rws-fleet-sig v2 <serial> <sig>, fromrws fleet sign), and a config whose serial isn't above the applied one is refused, so an older signed file can't roll an instance back; a fetched config can't change the[fleet]settings; when the reload refuses a fetched config the previous file is restored. 18.23 signature files still verify; re-sign to get rollback protection. - WAF (#77): MySQL's executable comments (
union/*!select*/) no longer hide SQL from rule 942120; command injection after;or|needs a shell-like argument, so text like "tired; head hurts" isn't blocked;rws --checkwarns when a WAF route has no body size limit. - OIDC sign-in (#73): a
return_towith a tab, newline, space or other control character is replaced by/(browsers drop tabs from URLs, so/%09/evil.examplewas an open redirect after login); query values are decoded as UTF-8. - PKCS#11 (#79): a
pin-value=in a key URI is hidden in the startup output andGET /admin/api/v1/config; URIs are percent-decoded per RFC 3986.
Fixed
- Cluster sync (#76): an admin change no longer waits on Redis — it's queued for the sync thread, which sends it at once; a Redis connect gives up after 2 s per address instead of the OS's long retry.
- FastCGI routes serve
/.well-known/(security.txt, app links); other dot-files stay refused. - The JSON escaping in the OAuth server, AWS Secrets Manager client and ACME
shares one implementation (
core::json::escape); the first two left control characters unescaped. - WebSocket upgrades through proxy routes sent the client's
X-Forwarded-Forand rws's own as two headers; they're one chain now. - PKCS#11: handshakes no longer wait on one shared session per key — up to 8 sessions sign in parallel.
18.23 3 releases: 18.23.0 – 18.23.2
18.23.2 — 2026-11-01
Fixed
- ACME: a chunked reply from the CA is decoded properly. The decoder skipped the first chunk-size line and read data as a size, so the body came back empty; Let's Encrypt chunks large orders (12 names here), and rws then waited for a status it never saw ("order timed out with status ''"). The framing now comes from the Transfer-Encoding header.
18.23.1 — 2026-11-01
Fixed
- The Windows release binary didn't build in 18.23.0 (the PKCS#11 signer
converted a
u64where Windows'CK_ULONGis 32 bits), so 18.23.0 has no Windows download; 18.23.1 does.
18.23.0 — 2026-11-01
Added
- FIPS build (#78): the
fipsfeature runs all TLS on aws-lc's FIPS 140-3 module with FIPS-approved algorithms only, checks every TLS config at startup, and says(FIPS)in--version; arws-<version>-x86_64-unknown-linux-gnu-fips.tar.gzrelease artifact. Every rustls config now namescrypto_provider()explicitly. - TLS keys in an HSM (#79): with the
pkcs11featuretls_key_filetakes apkcs11:URI (RFC 7512: token, object/id, module-path, pin-source) and handshakes are signed on the token — ECDSA P-256/P-384, RSA-PSS and PKCS#1;rws --checkopens the key. In the macOS, Windows and glibc FIPS release binaries. - Fleet config pull (#80):
[fleet] source(HTTPS with ETags,s3://,git+…#branch:path,{node}) fetched everyinterval_secs; an Ed25519 signature (rws fleet keygen,rws fleet sign),rws --checkand the reload must all pass before the config replaces the running one; outcomes POSTed toreport_urland shown instatus. Release binaries now includestorage-s3.
18.22 18.22.0 — 2026-11-01
18.22.0 — 2026-11-01
Added
- Admin users, roles and audit log (#75):
[admin] users = ["name:ENV_VAR:role"]adds named tokens withviewer,operatororadminroles; every change through the API, UI,rws ctlor MCP tools (and every refused attempt) goes to an audit log —GET /audit,rws ctl audit, an Audit page, andaudit_logfor a JSON-lines file;GET /whoami. Single sign-on for the admin UI withoidc_issuer/oidc_providerandoidc_roles(groups → roles), cookie changes guarded by anX-Rws-Adminheader. - Runtime state across replicas (#76): with
[cluster] redis(or[acme] redis) the IP blocklist, maintenance mode, drained backends, feature flags and cache purges changed on one replica apply on all of them within a second; Redis outages are ridden out (changes queue, an empty Redis is re-seeded from the replicas);statuslists the nodes. - Web application firewall (#77):
[middleware.waf]/[route.middleware.waf]with rws's own rules — SQL injection, XSS, path traversal and sensitive files, inclusion wrappers, command injection, cloud-metadata SSRF, Log4Shell, scanners — over decoded paths, arguments, form/JSON/multipart fields, cookies and headers; anomaly scoring, paranoia 1–3,blockordetect, exclusions by rule and path, customdeny/allow/log/scorerules;403problem+json,[waf]log lines,rws_waf_*metrics;waf::WafLayerfor code. - Support policy (#81): long-term-support lines (one minor every six months,
security and critical fixes for twelve months; 18.20 is the first, until
2027-11-01), security response targets and coordinated disclosure in
SECURITY.mdand a Support policy docs page.
18.21 18.21.0 — 2026-11-01
18.21.0 — 2026-11-01
Security
ForwardAuthLayer: a header named incopy_headernow only ever comes from the auth service — a client's own copy is dropped even when the service doesn't send one (it used to pass through). The auth service also getsX-Forwarded-Method/Proto/Host/Uri/Forset by rws, not the client's.OidcAuthremovesX-Rws-Oidc-ClaimsandX-Auth-Request-*headers a client sends, on excluded paths too;return_tomust be a local path.- An
[route.middleware.auth]table with an unknowntypemakes the route answer503(andrws --checkfail) instead of leaving it unprotected.
Added
- Local HTTPS (#71):
tls = "internal"(--tls=internal) makes rws its own certificate authority and serves a certificate forlocalhost,127.0.0.1,::1, the listen address, the virtual hosts andtls_internal_names, re-issued weekly without a restart.rws trustputs the CA in the system trust store (Linux, macOS, Windows, and the NSS database browsers use on Linux);rws untrustremoves it. - FastCGI (#72):
type = "fastcgi"routes run PHP through php-fpm (TCP or Unix socket, kept-alive connections) with front-controller routing,PATH_INFO, static files served by rws, scripts confined to the root and httpoxy-safe variables;rust_web_server::fastcgi::FastCgifor code. - Sign-in in the config file (#73):
[route.middleware.auth] type = "oidc"(an issuer's discovery, orprovider = "google" | "microsoft" | "github") withallowed_emails/allowed_domains/allowed_groups, signed-cookie sessions that survive restarts and work across replicas, andX-Auth-Request-User/Email/Groupsupstream;type = "forward"asks an auth service (Authelia, Authentik, oauth2-proxy).OidcAuthgainssigned_cookies,allow_emails,allow_domains,allow_groups,forward_headers,session_ttl, and an emptyredirect_urifollows the request's host. Release binaries now include thessofeature. - WebSockets through proxy routes (#82): a
type = "proxy"route relaysConnection: upgraderequests to a plain-HTTP backend (Action Cable, LiveView, Socket.IO, hot reload) on the main listener; the relay moved from the Gateway API controller toproxy::upgrade. - Cookbook (#74): complete configurations for a static site, a single-page
app with an API, Node, Python/Ruby and PHP apps, internal tools behind
sign-in, an API gateway and local development — each checked by
rws --checkin CI (cookbook_configs_pass_check).
Fixed
- The outbound HTTP client sends the port in
Hostwhen it isn't the scheme's default (OIDC discovery behind Keycloak on:8080built URLs without it). - The admin API's IP blocklist (and
rws ctl block) now applies in proxy mode too; it only covered the static-file server. Clients that aren't blocked still take the non-blocking proxy path.
Tests
ci/e2e/mtls_crl.sh: CRLs end to end with an openssl CA and curl — revoked client certificates refused after SIGHUP and withwatch = true, DER CRLs,rws --checkon a junk CRL.
18.20 18.20.0 — 2026-11-01
18.20.0 — 2026-11-01
Added
- systemd integration (#67), without libsystemd: with
Type=notifyrws saysREADY=1once it serves (listeners bound, certificates loaded),RELOADING=1/READY=1around a reload,STOPPING=1at shutdown, and pingsWATCHDOG=1from its event loop at halfWatchdogSec. Socket activation: listeners systemd passes (rws.socket, matched byFileDescriptorNameor port) are used instead of binding — restarts refuse nothing — including by every per-core runtime. The packages' unit isType=notifywithWatchdogSec=30and they installrws.socket. - CRLs for inbound mTLS (#68):
tls_client_crl_file(PEM or DER, comma-separated) makes revoked client certificates fail the handshake; re-read on reload and bywatch, parsed byrws --check;tls_client_crl_strict = truealso refuses stale CRLs and certificates no CRL covers. - Key rotation (#69):
JwtLayer::secrets([new, old])andsecret_with_kid(kid, secret)verify HS256 tokens signed with any of several secrets (a token'skidpicks one); the config file's jwt auth takesprevious_secret_env. htpasswd files are re-read when they change (adding or removing a user needs no restart), andhtpasswd_filemay list several. rws ctl(#70): the admin API from the command line —status,reload(exit 1 with the errors on a bad config),drain,maintenance,block/unblock,purge,caches,upstreams,certs [renew],logs [-f],traffic; tables for people,--jsonfor scripts. Address and token from[admin]in the config file,--admin,--token-fileorRWS_ADMIN_TOKEN(never an argument). The deb/rpm packages install anrwsctlsymlink.
Changed
- Proxied requests carry RFC 7239
Forwarded(for=…;proto=…;host=…) beside theX-Forwarded-*headers (#68), extending an incoming one. Backends that readForwarded(Spring'sForwardedHeaderFilter, Rails) now see it, with the valuesX-Forwarded-*already carry.forwarded_header = "off"(RWS_CONFIG_FORWARDED_HEADER) leaves it out.
18.19 18.19.0 — 2026-11-01
18.19.0 — 2026-11-01
Changed
- Licensed under MIT only.
LICENSEis now a single MIT file; earlier releases also offered Apache-2.0, CC BY 4.0, ISC and LGPL-3.0, and those releases keep that choice.CONTRIBUTING.mdsays contributions are accepted under MIT.
Added
mcp::openapi_tools(#66): OpenAPI 3.0/3.1 operations as MCP tools — input schemas from path, query and header parameters and the JSON body, output schemas from object responses, annotations from the method, andrequest(arguments)building each call's HTTP request. OnlyGEToperations unless included by operationId; local$refs inlined with depth, cycle and size limits. Fuzz targetopenapi_to_mcp.- The MCP gateway takes HTTP APIs as sources:
[[route.action.mcp.openapi]](McpGateway::openapi) turns an OpenAPI document's operations into<prefix>__<operation>tools, each call an HTTP request tobase_url(no redirects) with the API's credentials from the environment. McpServer::openapi_tools(app, spec, options): an app's own operations as MCP tools, each call run in-process through the app (the caller's identity inX-Rws-Mcp-Caller);AppWithState::openapi_spec(&config)(openapifeature) returns the documentopenapi()serves.- Config proxy routes choose the upstream
Host:preserve_host = truesends the client's,upstream_host = "…"a fixed name (:authorityover HTTP/3 upstreams). It was always the backend's address, and aheader_setrewrite ofHostwas silently dropped —rws --checknow warns about one.
Fixed
-
Admin UI: long config values are shortened in the middle (the full value on hover) instead of widening the page, nothing scrolls sideways on a phone any more (the layout's column, the seven-section bottom bar and the header fit), and sizes and uptime are formatted for the reader's locale (1023.97 KiB shows as 1 MiB, not "1024.0 KiB").
-
Config-file strings (
rws.config.tomlsettings and proxy sections) are TOML strings: a basic string's escapes (\n,\r,\",\\,\uXXXX, …) are decoded, a literal string ('…') is taken as written. They used to lose only their quotes, sobody = "a\r\nb"answered with a literal\r\nand the documentedbody = "{\"ok\":true}"with its backslashes. A backslash before anything else is still kept as written ("^/v\d+/"). Note: a value that relied on the old reading of a real escape — say a Windows path"C:\new"— now changes; write it as'C:\new'or"C:\\new". -
An escaped quote no longer ends a string for comment, array and inline-table splitting (
"a\"#b"lost everything after#), and inline tables keep non-ASCII text (it was rebuilt byte by byte and garbled).
18.18 18.18.0 — 2026-11-01
18.18.0 — 2026-11-01
Added
-
A2A push notifications: webhooks registered with
SendMessageorCreateTaskPushNotificationConfig(and Get/List/Delete) get every task update asapplication/a2a+json, with the config'sAuthorizationandX-A2A-Notification-Token; only URLs under the prefixes given toA2aServer::push_notificationsare called, without redirects, three attempts each.TaskHandle::artifact_chunkstreams an artifact in pieces. CI runs the official A2A compatibility kit (a2a-tck) againstexamples/a2a_tck.rs.A2aServer::extended_cardservesGetExtendedAgentCardto authenticated callers. -
[route.action] type = "a2a": an A2A gateway route. It serves the upstream agent's card with its JSON-RPC interface pointing at the route, forwards JSON-RPC calls (streams included) with headers from the environment instead of the caller'sAuthorization, and writes an audit line per call.
Fixed
http_clienttries every address a name resolves to, not just the first:localhost(often::1first) now reaches a server listening on IPv4 only, and so do hosts whose IPv6 address doesn't answer.- A2A: a task a client's follow-up message moves on (an
A2aReply::Taskfor a continued task) now notifies its streams and webhooks; onlyTaskHandleupdates did.
18.17 18.17.0 — 2026-10-31
18.17.0 — 2026-10-31
Changed
- Errors rws produces itself (proxy
502/503/504,413,431,408,401/403from the auth and filter layers,429, maintenance, misconfigured routes,AppError) answer with RFC 9457 problem details,application/problem+json({"type":"about:blank","title":"Bad Gateway","status":502}), instead of a plain-text line. Status codes and headers are unchanged. Seterror_format = "text"(RWS_CONFIG_ERROR_FORMAT) for the old bodies. Error responses lists them. - Proxied responses carry
Proxy-Status(RFC 9209):rws; received-status=200, or on failure the reason,rws; error=connection_refused(DNS, refused, timeouts, TLS, terminated, incomplete, protocol errors, no backend in rotation). Config-file routes,ReverseProxy, HTTP/2 and HTTP/3 reverse proxies, canary, ingress, gRPC routes and the Gateway API router.proxy_status = "errors"or"off"limits it,proxy_namenames the hop,proxy_status_next_hop = trueadds the backend address and error text (off by default: they reveal internal addresses). - Responses through a response cache (
CacheLayer, memory or disk, and[route.middleware.cache]) carryCache-Status(RFC 9211):rws; hit; ttl=42,rws; fwd=uri-miss; stored,fwd=stale,fwd=request,fwd=method,fwd=bypass; detail=private. An upstream'sCache-Statusis kept.cache_status = falseleaves it out.
Added
a2a::A2aServer(#65): an agent other AI agents call over A2A 1.0 (JSON-RPC binding): the Agent Card at/.well-known/agent-card.json,SendMessage(a direct message or a stored task; continuing a task that waits for input),GetTask,ListTasks,CancelTask,A2A-Versionchecks and the A2A error codes; long-running tasks updated from other threads through aTaskHandle(SendMessagewaits for them, or answers at once withreturnImmediately);SendStreamingMessageandSubscribeToTaskas server-sent events; bearer tokens with per-caller tasks, listed on the card. Fuzz targeta2a_request.
Fixed
install.shfalls back to thereleases/latestredirect when the GitHub API answers nothing (its 60 requests an hour per address run out on shared CI runners and office networks), instead of failing with "could not find the latest release".service_discovery::json_lite(used for Vault, AWS Secrets Manager, Consul, etcd, Docker and GCS responses) refuses JSON nested deeper than 128 levels instead of recursing until the stack overflows.- Host routing (
[route.match] hostandRouter::with_host) goes by the request'sHostheader (:authorityover HTTP/2 and HTTP/3), falling back to SNI only without one. It went by SNI first, so a browser reusing its connection to one name on a shared certificate for another name got the first name's routes (seen on rws8.tech: the site served Gitea after a visit to git.rws8.tech). HTTP/3 requests now carry:authorityasHost, as HTTP/2 ones did.Router::with_hostalso ignores case and a port it doesn't name, as config routes already did.
18.16 18.16.0 — 2026-10-31
18.16.0 — 2026-10-31
Added
- Translations (
i18nmodule, #33): message catalogs per language (<language>.toml, a flat TOML subset),Accept-Languageparsing and RFC 4647 negotiation (AcceptLanguage, also an extractor), fallback from regional to base to default language,{name}placeholders, plural forms for the common language families (plural_category), andTranslator::localizeforContent-Language+Vary. No new dependency. Fuzz targetsaccept_language,i18n_catalog. GcsStorage(storage-gcsfeature): Google Cloud Storage for theStoragetrait, over the JSON API with no Google SDK. Credentials as Google's client libraries find them:RWS_GCS_ACCESS_TOKEN, a service account key orauthorized_userfile (GOOGLE_APPLICATION_CREDENTIALSor gcloud's default file), or the metadata server (Compute Engine, GKE, Cloud Run);RWS_GCS_CREDENTIAL_SOURCE=nonefor emulators. CI now runs every storage backend's tests.
Fixed
- The
wasm32-wasip2build (rws-wasm-shim) compiles again: WebSocket routes, upstream metrics and the MCP gateway are native-only there. CI now builds the component and serves pages, a 404 and a streamed file throughwasmtime serve(ci/e2e/wasm_shim.sh), so it can't break unnoticed again.
18.15 18.15.0 — 2026-10-31
18.15.0 — 2026-10-31
Added
-
traffic::classify(ip, user_agent, path): people (browsers), AI agents (training, search, assistants) and bots (search engines, SEO, monitoring, link previews, scanners, tools), from bundled lists — ai.robots.txt and crawler-user-agents (MIT,src/traffic/NOTICE.md) — and the IP ranges Google, Bing, Apple, DuckDuckGo, OpenAI, Perplexity and Common Crawl publish; a User-Agent claiming one of those crawlers from elsewhere is marked spoofed.ci/gen_bot_lists.pyregenerates the tables (--checkin CI). Fuzz targettraffic_classify. -
Traffic counting (
[traffic], on whenever the admin API is): every request — logged or not — lands in hourly counts per host and group (people, AI, bots), daily unique visitors (hashed with a secret that's never stored; no IPs or User-Agents kept) and daily top lists (pages, AI agents, bot kinds, referrers, 404s). A browser counts as a person only once it loads a stylesheet, script or font. Saved every 5 minutes totraffic.jsonbeside the certificate (orpersist), 30 days by default, bounded to a few MB at any load. About 160 ns per request. The file is readable by its owner only (0600). -
Traffic page in the admin UI: visitors, page views and requests for people, AI agents and bots over a day, a week or 30 days, change from the period before, a chart, and tables of the pages people read, AI agents (verified by network or not), the pages they read, bots by kind, referrers and 404s; a button per site. Admin API
GET /trafficand MCP tooltraffic_summary(the binary has 25 tools). Docs: Traffic insights. -
A static path that names nothing but ends with punctuation copied along with a link (
/docs/http2/):from an llms.txt line,/docs/install.) redirects (301) to the path without it when that exists — those requests were 404s. -
min_free_disk(RWS_CONFIG_MIN_FREE_DISK, default the larger of 1% and 1 GiB): below it rws stops writing the access-log file and disk-cache entries (dropped and counted) until space returns — a full disk costs log lines, not the server.rws_disk_free_bytes,rws_disk_low,rws_access_log_dropped_lines_total,rws_cache_skipped_writes_total;diskin the admin/statusand a warning on the admin UI's Overview. Access-log write errors are logged at most once a minute. A "Disk safety" section covers journald, Docker and Kubernetes log limits.
Changed
- The admin UI registers its Phosphor icons with
@lit-material/icon'sregisterIcons()and renders them aslit-material-iconinstead of its own name-to-SVG helper; it looks the same. starters/fullstack's frontend uses lit-material components rather than raw<input>/<ul>: an outlined text field, a list with a delete icon button per note, an empty state, and a snackbar for failed requests (it used to print them inline). Agents that copy the starter now start from those components.- The access-log file rotates at 100 MiB by default (
access_log_max_sizewas0, never) — at most 600 MiB with the 5 kept files. Set it to0to keep rotating with logrotate. - The JSON access log adds
host,user_agentandrefererafterbytes, each only when the request sent that header — who visited, for which site, from where. Existing fields and their order are unchanged.
18.14 18.14.0 — 2026-10-31
18.14.0 — 2026-10-31
Added
authz::Identity: every authenticator hands its caller to the rest of the request —JwtLayer(sub, or.identity_claim(..)),OidcAuth,SamlSp,BasicAuthLayer,ForwardAuthLayer(.identity_header(..)) and MCP bearer / OAuth tokens. Read it withIdentity::current(); set your own withauthz::with_identity/scope_identity. Not a header, so clients can't forge it. A value from a token, header or login is always a user id (Identity::user): it can't name another type or a set such asgroup:eng#member. Async handlers see the caller too.- Relationship-based access control (Zanzibar style):
authz::Schema(relations as unions ofuser,group#member, another relation,parent->viewer), tuples (doc:42#editor@user:alice),TupleStorewithMemoryStore, andAuthorizer::check/explain— an iterative walk with a visited set, 25 relations deep and 1000 reads at most. Fuzz targetauthz_parse. AuthzLayer(401without a caller,403when not allowed) with object templates (doc:{path:2},{query:k},{header:H}; path segments percent-decoded, and a path with./..or an encoded/names nothing, so/docs/42/../7can't pass a check on doc 42), and in the config file[authz](schema per[authz.type.<name>], seedtuples) plus[route.middleware.authz] relation / object;rws --checkvalidates them; runtime tuples survive a reload.ci/e2e/authz.sh.authz::SqlStore: tuples in SQLite, Postgres or MySQL (a model feature), with a 1 s read cache;[authz] store = "sql"(RWS_DB_*).- Authorization at runtime: admin API
GET /authz,GET/POST/DELETE /authz/tuples,POST /authz/check(with the path that allowed it); an Authorization section in the admin UI; MCP toolsauthz_check,authz_tuples,authz_write,authz_delete(the binary has 24 tools).admin::ops::register_authorizerfor library apps. - The proxy config parser accepts arrays spanning several lines (comments and a trailing comma allowed).
18.13 18.13.0 — 2026-10-31
18.13.0 — 2026-10-31
Added
- HTTP/3 to upstreams:
[[upstream]] protocol = "h3"sends requests over QUIC tohttps://backends (one multiplexed connection per backend, streaming both ways, trailers), on both forwarding paths. A backend QUIC can't reach is served over TCP and kept there for 5 minutes, counted byrws_upstream_h3_fallbacks_total.rws --checkvalidatesprotocol.proxy::H3ReverseProxydoes the same in code.ci/e2e/h3_upstream.sh: rws to rws over QUIC, and the TCP fallback.
18.12 18.12.0 — 2026-10-31
18.12.0 — 2026-10-31
Added
- 103 Early Hints:
early_hints::send(links)from any handler or middleware, andEarlyHintsLayerfor a fixed list, write a103head withLinkvalues before the response. HTTP/2 and HTTP/3 by default; HTTP/1.1 withearly_hints_http1 = true(RWS_CONFIG_EARLY_HINTS_HTTP1); never HTTP/1.0. At most 4 per request. - Early hints from the config file:
[route.middleware] early_hints = ["</app.css>; rel=preload; as=style"]on any route (proxy routes keep the async forwarder) or in the global[middleware]table, and proxies pass a backend's own103on (itsLinkvalues) instead of dropping it.rws --checkchecks the values;rws_early_hints_total{source}on/metrics;ci/e2e/early_hints.sh. - Dictionary compression codec (RFC 9842):
compression::dictionaryencodes and decodesdcz(zstd, the dictionary as a raw prefix) anddcb(brotli custom dictionary), parsesAvailable-Dictionaryand negotiates the coding. Output checked against thezstdCLI. Fuzz targetavailable_dictionary. - Dictionary compression for static files:
compression_dictionaries = ["/js/app.*.js"](RWS_CONFIG_COMPRESSION_DICTIONARIES) offers matching files as dictionaries (Use-As-Dictionary), keeps their bytes (32 MiB, oldest out) and sends later versions asdcz/dcbdeltas to browsers that hold an earlier one.ci/e2e/dictionary.sh: Chromium decodes the delta; thezstdCLI and libbrotlidec decode each coding.
18.11 18.11.0 — 2026-10-31
18.11.0 — 2026-10-31
Added
-
Cache purge:
CacheLayer::purge(&Purge::{All, Exact, Prefix})for memory and disk caches; HTTPPURGE(a trailing*purges a prefix) with a bearer token from.purge_token()/[route.middleware.cache] purge_token_env;cache::registryof named caches (app,route:<name>); admin APIGET /cachesandDELETE /caches/<name>?path=&prefix=(/cacheunchanged), a purge field in the admin UI, andpath/prefixon thecache_clearMCP tool.PURGEis now an accepted request method (it was a400). -
Request mirroring:
[route.middleware.mirror](upstreamorbackends,percent) copies a share of a route's requests to other backends and drops their answers; fire-and-forget through a bounded queue, so a slow or down mirror never affects responses.proxy::mirror::Mirror/MirrorLayerin code,rws_mirror_requests_totalon/metrics,ci/e2e/mirror.sh. -
Disk cache:
CacheLayer::disk(dir, max_bytes)and[route.middleware.cache] dir/max_sizekeep cached responses in files, bounded by total size and kept across restarts. Fuzz targetcache_entry.
Changed
- The response cache honours the response's
Cache-Control: s-maxage, elsemax-age, when shorter than the layer'sttl;max-age=0responses are no longer stored. Before, every cacheable response was kept for the fullttl.
18.10 3 releases: 18.10.0 – 18.10.2
18.10.2 — 2026-10-30
Added
Response::with_status(status)andimpl Default for Response: build a response without a struct literal.
Changed
- Header writing and upstream-response parsing use byte searches
(
memchr) for CR/LF checks and line splits, and a cheaper blank-line test. Output is unchanged; a same-run benchmark showed no measurable throughput change.
18.10.1 — 2026-10-30
Added
starters/fullstack: a lit (@lit-material) frontend served by rws as static files with the SPA fallback, a JSON API under/apiwithApp::with_async_state, PostgreSQL through the standardPG*variables (in memory withoutPGHOST), a distroless multi-stageDockerfile, and GitHub Actions workflows that test, push to GHCR and deploy to a kube-dc project, with a preview per pull request removed when it closes.
Changed
- Admin UI built on the new lit-material components (status, stat, empty-state, log-viewer, table, chart, adaptive navigation): one navigation that is a drawer, rail or bottom bar by window width; the log stops following while you scroll up, with a "new lines" button; the overview adds a requests-per-second sparkline.
Fixed
- Admin API
GET /statusandGET /build(and thefeature_flagsMCP tool) list thewasm-pluginsfeature.
18.10.0 — 2026-10-30
Added
-
Admin API on a listener of its own (
[admin] listen, off by default): bearer token from the environment variabletoken_envnames (required, on loopback too; without it the listener doesn't start andrws --checksays so), browser origin checks,GET /admin/api/v1/status.admin::AdminApi/AdminConfig/startfor library users.ci/e2e/admin.sh. -
Admin API: effective config (secrets hidden), reload with its outcome (
config_reload::last_reload,report_error), counters, build features, rate limits, CORS, maintenance, blocklist, feature flags, response cache, routes, recent requests and errors.admin::opsholds the shared code; the binary's MCP tools call it, soserver_confignow lists everyRWS_CONFIG_*setting with secrets hidden. -
Admin API: upstreams with each backend's weight, health, circuit-breaker state and drain state; drain and undrain a backend (
PUT /admin/api/v1/upstreams/<name>/drain; all drained →503); certificate inventory with expiry and the ACME renewal loop's last outcome;POST /admin/api/v1/certificates/reneworders a certificate now (acme::request_renewal,acme::renewal_status). -
Admin API:
GET /admin/api/v1/logs(the last access-log lines, up to 500) andGET /admin/api/v1/logs/stream(a live tail as server-sent events), fed from the access-log sink's writes (log::tail). -
Admin UI at
/admin/on the admin listener: overview with a live requests-per-second chart, upstreams with drain switches, certificates and renew, controls (maintenance, reload, cache, blocklist, flags), config and a live log. Built with lit-material fromadmin-ui/and embedded in the binary; strict CSP;ci/e2e/admin_ui.shdrives it in headless Chromium. -
WebAssembly plugins (feature
wasm-plugins, on in the release binaries):wasm_plugin::WasmLayerand[route.middleware.wasm]run a core module on each request (pass, edit headers or target, or answer) and response (edit status and headers). No imports (no WASI); CPU bounded by fuel, memory bymemory_mb; a fresh instance per request; failures answer500and count inrws_wasm_plugin_errors_total. A route whose plugin can't load answers503. Example plugin inexamples/wasm_plugin, fuzz targetwasm_plugin_output,ci/e2e/wasm_plugin.sh.
Changed
- The
rwsbinary's maintenance mode now also covers config-file proxy routes.MaintenanceLayerpasses requests through while it is off, so proxy routes keep their non-blocking forwarder.
18.9 2 releases: 18.9.0 – 18.9.1
18.9.1 — 2026-10-29
Fixed
- rws8.tech: the site build failed when an older docs version's tag has
docs/sidebar.jsonbut nodocs/astro.config.mjs(18.8), so 18.9.0's site was not published; the LLM proxy docs page's front matter didn't parse. No changes to the library or the binary.
18.9.0 — 2026-10-29
Added
- LLM proxy (
llm::LlmProxy, and[route.action] type = "llm"in the config file): one endpoint in front of OpenAI-compatible and Anthropic providers. Virtual keys per caller (the provider's key is swapped in), fallback to the next provider on no answer,429or5xxbefore the first byte, token usage from JSON bodies and event streams (OpenAI streams getstream_options.include_usage), token budgets per identity in memory or shared through Redis,rws_llm_*metrics (requests, tokens per identity, time to first token, fallbacks, budget rejections) and an optional audit line per request.llm::UsageParserreads usage out of a provider response on its own. Fuzz targetllm_usage,ci/e2e/llm_proxy.sh,examples/llm_proxy.rs. - Proxied requests carry
X-Forwarded-Proto(httpsorhttp, as the client connected) unless the client already sent one: the HTTP/1.1 and HTTP/2 upstream forwarders, config-file proxy routes, Gateway API routes, mirrors and upgrades. McpServer::before_tool_call(|ctx, tool| …): refuse a call before it runs with a message the client gets as a tool error.McpServer::after_tool_call(|ctx, call| …): every finished tool call with its outcome (ToolCallOutcome: ok, tool error, refused, denied) and duration.- MCP gateway from the config file:
[route.action] type = "mcp"with[[route.action.mcp.upstream]],caller,allowandlimittables, secrets from environment variables, checked byrws --check;ci/e2e/mcp_gateway.shruns it against two upstreams. McpServer::resource_filterandprompt_filter, liketool_filterfor resources and prompts.- MCP gateway:
Upstream::header_for(name, |claims| …)sends a per-caller header on tool calls (credentials injected server-side per user).Upstream'sDebugno longer prints header values. - MCP gateway: upstream prompts (
<prefix>__<name>) and resources (their own URIs) are federated and filtered by the sameallowrules as tools. - MCP gateway:
McpGateway::audit_log(true), one JSON line per tool call in the access log (time, caller, tool, upstream, outcome, duration). - MCP gateway:
McpGateway::limit(tools, max_calls, window_secs), per caller and tool; a refused call doesn't reach the upstream. - MCP gateway:
McpGateway::refresh_every(default 5 minutes) re-reads upstream tool lists and applies the difference, withnotifications/tools/list_changedto clients; tools were listed only atbuild. - MCP gateway: an upstream that only speaks MCP 2026-07-28 (it refuses
initialize) is reached statelessly, afterserver/discover, with the version in_metaand theMcp-Method/Mcp-Nameheaders; 2026-only result fields are dropped so 2025 clients can call its tools.
API changes
ConnectionInfohas a new public field,tls: bool(the client connected over TLS). Code that builds aConnectionInfowith a struct literal must add it;ConnectionInfo::new(client, server)andDefaultnow exist, soConnectionInfo { client, server, ..Default::default() }keeps working when fields are added later.
18.8 5 releases: 18.8.0 – 18.8.4
18.8.4 — 2026-10-29
Added
-
directory_listing = false(RWS_CONFIG_DIRECTORY_LISTING): a directory without anindex.htmlanswers 404 instead of listing its files. Defaulttrue, as before. -
install.sh(curl -fsSL https://rws8.tech/install.sh | sh): installs the release binary for Linux or macOS after checking its.sha256, into/usr/local/binor~/.local/bin;--versionand--dirpin a release or a directory. The site's install panel offers it, and CI runs it on Linux and macOS. -
Proxied requests carry
X-Forwarded-Host(theHostthe client sent) unless the client already sent one: the HTTP/1.1 and HTTP/2 upstream forwarders and Gateway API upgrades. -
config_check::check_str_offline:rws --check's checks on configuration text without reading this machine's files or environment, for text from someone else. -
The docs MCP server at
https://rws8.tech/mcp(site/mcp):versions,search_docs,get_page,get_example,api_item,setting,check_configandchangesfor every minor release of the current major, page resources and astart_rws_appprompt. Releases attach its binary; the site build writes its data (/mcp/<minor>.json).
Changed
- Startup no longer prints the full usage text (about 150 lines) before
the lines that matter;
rws --helpstill does. With HTTP/3 the app is built once instead of once per listener, so its startup notes ("MCP tools not mounted") print once.
18.8.3 — 2026-10-29
Fixed
- Automatic HTTPS against Let's Encrypt: the ACME client closed its side of the connection before reading the newNonce reply, and Let's Encrypt's front end answers nothing to such a HEAD, so every order failed with "Replay-Nonce missing from newNonce response" (Pebble, which CI tests against, tolerated it). The request is no longer half-closed.
watch = truewith[acme]: the watcher started before the first certificate was ordered, saw the certificate and key being written and sentSIGHUPbefore the handler was installed, which ended the process. It now starts once ACME has finished, before the servers run.- Adding a name to
[acme] domainsnow gets a certificate for it: the stored certificate counted as current while it was valid, even when it didn't cover every configured name, so the new name kept the old certificate until renewal. A certificate missing a configured name is ordered again.
Website
- rws8.tech is a new site built in
site/(lit-material, prerendered with Lit SSR) and served by rws itself: a landing page, benchmarks charts, a config playground whose every output passesrws --check, and the docs for every minor release of the current major under/docs/<minor>/. Old doc URLs redirect to/docs/…. Starlight and the GitHub Pages deploy are gone; each release attachesrws8-site-<tag>.tar.gz, which the server installs.
Documentation
- Config file reference: the rewrite rule types are
header_set,header_remove,uri_set,uri_strip_prefix,uri_add_prefix,statusandbody_replace; the page listed names (set_header,set_status, ...) thatrws --checkrejects.
18.8.2 — 2026-10-28
Documentation
- Gateway API benchmark results (docs/deployment/kubernetes-gateway-api):
rws against Envoy Gateway, NGINX Gateway Fabric, Traefik, kgateway and
Istio over HTTP/1.1, HTTPS, HTTP/2, 1 MiB bodies and a filter-heavy route;
the harness (
bench/gateway/run.sh, workflowgateway-bench.yml) covers those scenarios. No code changes.
18.8.1 — 2026-10-28
Changed
- Gateway API router: requests are forwarded on the connection's task through the async upstream forwarder (plain and BackendTLSPolicy backends; pools of up to 1024 idle connections per endpoint) instead of holding a blocking-pool thread each. At 256 connections the blocking path fell to 15k req/s with 119 ms p99 and some failed requests in the gateway benchmark. Upgrades and h2c backends keep the blocking path.
- Helm chart: with
gatewayAPI.enabledthe pods get no CPU limit (theresources.limits.cpudefault of500mis left out; memory and requests apply as set). A Gateway API data plane serves every Gateway's traffic, and half a CPU throttled it into high tail latency in the gateway benchmark. Deployments withoutgatewayAPI.enabledare unchanged.
18.8.0 — 2026-10-28
Added
- Kubernetes Gateway API controller (#19,
gateway-apifeature; see docs/deployment/kubernetes-gateway-api): conformant with Gateway API v1.6.3 (standard channel) for the GATEWAY-HTTP, GATEWAY-GRPC, GATEWAY-TLS, GATEWAY-TCP and GATEWAY-UDP profiles with every standard-channel extended feature, in shared and provisioned (a Deployment per Gateway) modes. HTTPRoute (matching, the filters, timeouts, mirroring, CORS, h2c and WebSocket backends), GRPCRoute, TLSRoute (passthrough and terminate), TCPRoute, UDPRoute, ListenerSet, ReferenceGrant, BackendTLSPolicy (with SAN checks), client-certificate validation, static addresses; a Service and EndpointSlice per Gateway, Lease leader election, Helm values (gatewayAPI.*), and a CI job running the official suite in kind in both modes. The Linux release binaries and the container image include it (off unless enabled; it doubles the binary, so macOS and Windows builds don't).
Fixed
- HTTP/2 requests carry their
:authorityas theHostheader when the client sent nohostfield (RFC 9113 §8.3.1): applications, routers with.with_host, and the Gateway API router saw no host for HTTP/2 requests.
Changed
- The minimum supported Rust version is 1.99 (was 1.88): kube 4.2, under the
gateway-apifeature, and its dependencies need 1.89+, and the project now tracks the latest stable release.
18.7 18.7.0 — 2026-10-27
18.7.0 — 2026-10-27
Added
-
OpenAPI request and response schemas (#22):
OpenApiConfig::operation(method, pattern, Operation)describes an operation's summary,operationId, tags, JSON request body (.body::<T>()), responses (.response::<T>(status, …),.status(…)), query parameters (.query::<T>()) and path parameter types, with schemas fromJsonSchema— the derivation MCP tools use, so serde renames are followed.examples/mcp_inventory.rsdescribes its REST API;ci/e2e/openapi.shvalidates the document with openapi-spec-validator. -
Tower interop, opt-in (#23,
towerfeature):tower::mount/TowerAppserve a Tower service (a tonic gRPC server, tower-http'sServeDir, an axumRouter) from an rws app, bodies streaming both ways with gRPC trailers;TowerLayeruses a Tower layer (tower-http) as rws middleware;TowerServiceserves an rws app from hyper or axum. Tower futures run on a dedicatedrws-towerruntime. rws's own request path is unchanged, and the default build gets no new dependency.examples/tower.rs(tonic-health + tower-http);ci/e2e/tower.shcalls it with grpcurl over h2c. -
{param}route syntax (#42):/users/{id}and/files/{*path}beside/users/:idand/files/*path— what axum 0.8 and OpenAPI use — inRouter,AppWithState,AsyncAppWithStateand WebSocket routes;{{and}}are literal braces. OpenAPI operations match routes in either spelling. -
Starters (#42):
starters/api(JSON API + OpenAPI 3.1) andstarters/mcp(MCP server), standalone projects with their ownAGENTS.md, copyable withcargo generate;ci/e2e/starters.shbuilds and tests them against the checkout on every push. -
An agent pack (#42):
agents/skills/rws/SKILL.md(Agent Skills: Claude Code, Codex, …) with a Cursor rule and Copilot instructions generated from it (ci/gen_agents.py), published atrws8.tech/agents/. -
llms.txt/llms-full.txton the site, at the root and per release under/<major.minor>/(they were only in the repository: the site's links to them were broken). Docs page: getting-started/ai-agents.
Changed
/openapi.jsonis OpenAPI 3.1.0 (was 3.0.3):JsonSchemaemits JSON Schema 2020-12, which 3.1 uses as is.OpenApiConfighas a new public field,operations; code that builds it with a struct literal must set it (Vec::new()), or useOpenApiConfig::new.examples/mcp_inventory.rsneeds theopenapifeature too.- A route pattern segment written
{name}is now a parameter; before 18.7.0 it matched the literal text{name}. Write{{name}}for literal braces.
18.6 18.6.0 — 2026-10-27
18.6.0 — 2026-10-27
Added
- Config-file proxy parity (#21): an
[[upstream]]takesweights(smooth weighted round-robin; proportionalrandomandleast_connections),[upstream.sticky](aHttpOnlycookie naming the backend by a hash of its URL),[upstream.circuit_breaker](passive health checks: failing backends leave rotation forrecovery_secs;503+Retry-Afterwhen all are out) and[upstream.retry](idempotent requests with a buffered body go to another backend on no response or a listed status). All checked byrws --check. - Per-upstream metrics on
/metrics:rws_upstream_requests_total,rws_upstream_request_duration_seconds,rws_upstream_retries_total,rws_upstream_backend_up,rws_upstream_circuit_breaker_state. ci/e2e/proxy_policies.shruns these against real backends.http_server_request_duration_seconds(#25): the OpenTelemetryhttp.server.request.durationmetric, recorded by the server core for every request on HTTP/1.1, HTTP/2 and HTTP/3, labelled by method, status, scheme and protocol version.- Prometheus native histograms (#25):
/metricsanswers in the protobuf format when the scraper asks for it (Prometheus withscrape_native_histograms), with exponential buckets forhttp_server_request_duration_seconds.ci/e2e/native_histograms.shchecks it against Prometheus 3.15. - OTLP metrics export (#25):
otel::metrics::start/start_from_envpushhttp.server.request.durationto an OpenTelemetry collector over OTLP/HTTP (JSON, cumulative) everyOTEL_METRIC_EXPORT_INTERVAL, with a last export on shutdown. Therwsbinary exports metrics and traces (wrapping everything inOtelLayer) whenOTEL_EXPORTER_OTLP_ENDPOINTis set.OTEL_EXPORTER_OTLP_{METRICS,TRACES}_ENDPOINTand…_HEADERSare honoured.ci/e2e/otlp.shchecks it against otelcol-contrib 0.162. - Automatic client spans and W3C Baggage (#25): inside a request traced by
OtelLayer,http_client::Client/AsyncClient, the HTTP/1.1 proxies andDbPool/DbTransactionstatements get client spans, and outbound calls carrytraceparentandbaggage(otel::Baggage,current_baggage,set_baggage).otel::Contextcarries a span across threads (used forAsyncAppWithStatehandlers);otel::detached_spanis aSendspan for async code.ci/e2e/otlp.shfollows a proxied request into the collector. New fuzz targetotel_baggage. - TLS metrics (#25):
rws_tls_handshakes_total{tls_protocol_version,tls_cipher,tls_group},rws_tls_handshake_failures_totalandrws_tls_certificate_expiry_timestamp_seconds{name}(default certificate, virtual hosts, on-demand names).
Fixed
- HTTP/2 over cleartext (h2c) no longer sends
Strict-Transport-Security. - Trace and span IDs are random: they were a per-process counter (plus the start second), so two rws instances in one trace minted the same span IDs.
- OTLP span export no longer runs on the request thread when a batch fills
(a background thread sends it; partial batches go out after 5 s), honours
the endpoint's path and
https://, and escapes span names and attribute values in its JSON.
Changed
-
rustls is built with
prefer-post-quantum(its own default, which rws'sdefault-features = falsehad dropped): the server now picks the X25519MLKEM768 hybrid key exchange when a client offers it (current Chrome, Firefox, Safari, curl with OpenSSL 3.5), instead of plain X25519, and outbound connections (proxy, ACME, HTTP client) offer it first. -
proxy_config::UpstreamConfighas new public fields (weights,sticky,circuit_breaker,retry); code that builds it with a struct literal must set them (Vec::new()/None).
18.5 18.5.0 — 2026-10-27
18.5.0 — 2026-10-27
Added
- MCP 2026-07-28 beside the session-based versions, on one endpoint (#15):
stateless requests (
_metaversion and capabilities,MCP-Protocol-Version/Mcp-Method/Mcp-Namechecked against the body:-32602,-32020,-32022, all400),server/discover,resultTypeandserverInfoon every result,ttlMs/cacheScopeon cacheable ones (.cache_hints),subscriptions/listen(acknowledged, filtered, tagged), request-scoped progress and log messages (ctx.log, only with alogLevel), and multi round-trip requests:McpContent::input_required(InputRequired::new() .elicit(..).sample(..).list_roots(..).state(..)),PromptReplywith.prompt_with_context,ctx.input_response/elicitation_content/request_state(HMAC-signed, bound to method, name, caller and 10 min;.request_state_keyfor replicas) /client_supports; a request for an undeclared capability is-32021. Removed methods are404 -32601there. Official conformance suite 0.2.0-alpha.12 in CI: every scenario 2026-07-28 requires passes, and 2025-11-25 stays at its baseline (#16). - The MCP Tasks extension (
io.modelcontextprotocol/tasks, #15): a tool returnsctx.start_task(|task| ...)— a task handle for clients that declared the extension (tasks/get,tasks/update,tasks/cancel,notifications/tasksonsubscriptions/listen), the work run inline for any other.TaskContext::inputparks the task asinput_requireduntiltasks/updateanswers;TaskErrormaps to completed-with-error, failed or cancelled;.task_required(name)refuses non-declaring clients (-32021);.task_ttl,.max_running_tasks(256: each running task holds a thread). Tasks belong to their caller. Mcp-Param-*headers (MCP 2026-07-28, SEP-2243): tool parameters markedx-mcp-headermust be mirrored in matching headers ontools/call(400 -32020otherwise); base64 header values must be canonical. The conformance suite's 2026-07-28 run now passes every check, 196, including the unscored ones.resources/templates/list: resources registered with a URI template are listed there;resources/listholds only concrete resources (it listed templates as resources before, which the suite flags).crate::core::sha256: SHA-256 and HMAC-SHA256, no dependency.- Streaming Server-Sent Events (#24):
Sse::stream()returns the response and anSseSender; events reach the client as they are sent, over HTTP/1.1, HTTP/2 and HTTP/3.sendwaits for room (bounded memory),try_senddrops,send_asyncfor async code;Err(SseClosed)once the client is gone, found by a keep-alive comment every 15 s.SseStreamsets the buffer and interval. The MCP server'sGET /mcpstream now uses it. - WebSocket routes (#24):
AppWithState::websocket/Router::websocket, orWebSocket::upgrade(request, handler)in any handler, hand the upgraded connection to the handler on a thread of its own.WebSocketConnection::recvreturns whole messages (fragments joined, pings answered, the closing handshake done, protocol errors closed with 1002/1007/1009);WebSocketSendersends from other threads. HTTP/1.1, plain and TLS, async andhttp1builds.examples/realtime.rs; e2e with Node's WebSocket and fetch (ci/e2e/realtime.sh).
Fixed
SseEventencoding: a lone\rindata, or a line break inidor the event type, could add SSE fields of its own;datais now split at every line end andid/event type keep one line.
18.4 18.4.0 — 2026-10-27
18.4.0 — 2026-10-27
Fixed
- Per-core runtimes: startup returns only once every runtime's socket is bound. Between the setup listener closing and those sockets opening, a connection could be refused or reset; the gap is now microseconds, and "Started N per-core runtimes" is printed once the port is served again.
- A WebSocket Close frame whose reason isn't UTF-8 now fails the frame, as
RFC 6455 §7.1.6 requires (text frames already did). It was decoded
lossily, which could make the reason up to three times the frame payload
limit (found by the
websocket_framefuzz target).
Added
- TLS-ALPN-01 (RFC 8737, #17):
[acme] challenge = "tls-alpn-01"gets and renews certificates on the HTTPS port alone — no port 80. At startup a temporary acceptor answers on the HTTPS socket; afterwards the TLS listener answersacme-tls/1handshakes with the challenge certificate (and only those). Tested against Pebble, first issuance and renewal. - DNS-01 and wildcard certificates (#17):
[acme] challenge = "dns-01"publishes_acme-challengeTXT records throughdns_provider = "rfc2136"(a DNS UPDATE to the zone's primary server, signed with TSIG HMAC-SHA256/512 — BIND, Knot, PowerDNS, …) or"exec"(a program, for any DNS API), waits until the record is visible, and removes it afterwards;*.example.comindomainsgets a wildcard certificate. Refusals are explained (REFUSED, NOTAUTH, TSIG BADSIG/BADKEY/BADTIME). Tested against Pebble and BIND (ci/e2e/acme_dns01.sh); the DNS reply parser — now one module,dns, shared with SRV service discovery — is fuzzed (fuzz/fuzz_targets/dns_message.rs). - DNS-01 through the Cloudflare and Route 53 APIs (#17):
dns_provider = "cloudflare"(an API token,dns_api_token) or"route53"(requests signed with AWS Signature V4 fromAWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY/AWS_SESSION_TOKEN); the zone bydns_zone_idor looked up;dns_api_urlfor a proxy or test double. Tested against stand-in APIs writing into BIND, signatures checked independently (ci/e2e/acme_dns_api.sh). challenge = "dns-persist-01"(#17, draft-ietf-acme-dns-persist): one TXT record at_validation-persist.<domain>you publish once — no port, no DNS credentials on the server, wildcards too. rws prints the exact record, checks it's visible before asking the CA, and never changes it. Tested against Pebble.- On-demand TLS (#18): with
[acme] on_demand = trueand anon_demand_askendpoint, rws orders a certificate at the first handshake for a name the endpoint allows (GET <ask>?domain=<name>, 2xx) — for customers' own domains. Refused names get the default certificate; one order per name, at most four at once; certificates kept under.rws/acme/on-demand/, loaded at startup and renewed.rws --checkrequires the ask endpoint and refuses DNS-01 with it. Tested against Pebble (ci/e2e/acme_on_demand.sh). - Replicas sharing certificates through Redis (#18): with
[acme] redis, one replica orders each certificate (a lock in Redis) while the others wait and install it, renewals reach every replica, and any replica answers HTTP-01 and TLS-ALPN-01 challenges another presented. Redis being down isn't fatal. Tested with two replicas against Pebble (ci/e2e/acme_shared.sh): one order per certificate. [acme] challenge(RWS_CONFIG_ACME_CHALLENGE:http-01,tls-alpn-01,dns-01) and the DNS-01 settings (dns_provider,dns_server,dns_zone,dns_tsig_key,dns_tsig_secret,dns_tsig_algorithm,dns_exec,dns_propagation_secs);rws --checkvalidates them and accepts a wildcard domain withdns-01.
Changed
acme::AcmeConfighas new public fields (challenge,dns): code that builds it as a struct literal adds them (AcmeConfig::from_envis unaffected).- Startup output no longer prints the values of settings whose names
contain
SECRET,PASSWORDorTOKEN("(hidden)").
18.3 18.3.0 — 2026-10-27
18.3.0 — 2026-10-27
Added
- gRPC and HTTP/2 upstreams at parity with HTTP/1.1 (#13):
H2ReverseProxy,GrpcProxyand the config file'sgrpcaction keep one pooled, multiplexed connection per backend (a new handshake per request before); stream response bodies as they arrive and request bodies as they arrive, so server-streaming, client-streaming and bidirectional gRPC calls work; and pass the backend's trailers (grpc-status,grpc-message) to HTTP/2 and HTTP/3 clients, withte: trailersforwarded. A backend failing mid-call resets the client's stream. Response::trailersandresponse::Trailers: trailer fields sent after a body over HTTP/2 and HTTP/3 (HTTP/1.1 drops them).- Upstream client certificates (mutual TLS):
tls_client_cert(cert, key)onReverseProxy,H2ReverseProxyandGrpcProxy,[[upstream]] tls_client_cert_file/tls_client_key_file,UpstreamTls::new(ca, client).tls_ca_filenow also applies to HTTP/2 and gRPC upstreams (H2ReverseProxy::tls_ca_file,GrpcProxy::tls_ca_file). Middleware::answers_streamed_body: a layer that answers a request itself can take its body as a stream, whatever the inner application says.- gRPC-web bridge (#14):
GrpcWebLayertranslatesapplication/grpc-weband-textrequests to gRPC and the responses back — the status as the body's last frame — so browsers can call gRPC services through rws; the config file'sgrpcaction does it on its own. Checked from headless Chromium over HTTP/1.1 and HTTP/2 (ci/e2e/grpc_web.sh). - Inbound PROXY protocol v1 and v2 (#20):
proxy_protocol = true(RWS_CONFIG_PROXY_PROTOCOL) takes the client address from the header an L4 load balancer (HAProxy, AWS NLB, GCP) prepends to each connection, on the plain and TLS listeners; connections without one are closed. Tested behind HAProxy (ci/e2e/proxy_protocol.sh); parser fuzzed (fuzz/fuzz_targets/proxy_protocol.rs). - Cleartext HTTP/2 (h2c, prior knowledge) on the plain listener (#20): a
connection opening with the HTTP/2 preface is served as HTTP/2 — gRPC
without TLS,
grpcurl -plaintext,curl --http2-prior-knowledge. Anything else is HTTP/1.1 as before.
Changed
Responseandproxy_config::UpstreamConfighave new public fields (trailers;tls_client_cert_file,tls_client_key_file): code that builds them as struct literals adds them (trailers: None) — the constructors (Response::new,text,json,get_response) are unaffected. As withstream_pipein 17.110.0.- The config file's
grpcaction forwards over HTTP/2 (it used HTTP/1.1, so gRPC didn't work through it), andgrpc://,grpcs://andh2s://backends passrws --check. - HTTP/2 requests keep
te: trailersfor the application (it was validated, then dropped).
Fixed
- An HTTP/1.1 response with no body (a handler returning
Response::new(), a gRPC-web trailers-only error) had noContent-Length, so a keep-alive client waited for a body until the connection closed. It now saysContent-Length: 0(not for 1xx, 204 and 304, which never have content, nor for streamed bodies).
18.2 18.2.0 — 2026-10-26
18.2.0 — 2026-10-26
Security
- zstd 0.14.3, zstd-safe 8.2.0, zstd-sys 2.1.2 (RUSTSEC-2026-0391, -0398,
-0403, -0410, published 2026-10-16; taken although newer than the two-week
rule, being security fixes). rws calls only
zstd::bulk::compresson its own response bodies — a fresh context per call, no decompression, no WebAssembly build with zstd — so 18.1.0 isn't known to be exposed; the crate now requires zstd ≥ 0.14.3.
Added
- Runnable examples (#11):
hello,rest_api,static_site,reverse_proxy,sse_tickeranduploadjoin the MCP examples inexamples/, each with a testcargo testruns; listed on the new Examples page. CI now tests with theserdeandmacrosfeatures too, sorest_apiandmcp_inventoryrun on every push. AGENTS.md: a guide for coding agents building an app on the crate.- Helm chart published with each release (#26):
helm install my-rws oci://ghcr.io/bohdaq/charts/rws --version <version>(chart version = rws version, imageghcr.io/bohdaq/rws:<version>by default). New optionalIngressand prometheus-operatorServiceMonitor;helm/prometheus-adapter-values.yamlserves the HPA's request-rate metric. CI lints the chart, checks it with kubeconform and installs it into kind with TLS on and off. - deb and rpm packages (#27) for x86_64 and arm64 on each release:
/usr/bin/rws, the hardenedrws.service(now the one on the systemd page; it serves/var/www/rwsand reads/etc/rws/rws.config.toml), started on port 7878 on install, and signed apt and dnf repositories athttps://rws8.tech/aptand/rpm(newest release; the rpm files are signed too). CI builds the repositories with a throwaway key and installs from them and from the files on systemd hosts. The release workflow now pushes the rws8.techdocsbranch as one orphan commit per release (the branch is only a deploy target; packages would bloat its history). - Windows service (#27):
rws --windows-service=<directory>runs under the Service Control Manager; Stop and Shutdown end it gracefully (server::request_shutdown, which library users can call too). New page Windows. Adds thewindows-servicedependency on Windows only. - winget manifests (
packaging/winget/generate.sh) and a nixpkgs expression (packaging/nix/package.nix), checked in CI and submitted upstream per release (#27).
Fixed
- Helm chart with
tls.enabled(its default): liveness/readiness probes and the Prometheus scrape annotations used plain HTTP against the TLS port, so pods never became ready; they now use HTTPS (the Kubernetes docs' YAML had the same mistake). The HPA's custom metric was anExternalrws_route_requests_totalnothing served; it is now thePodsmetricrws_requests_per_secondfrom the Prometheus Adapter rule. The chart's scrape annotations moved frompodAnnotationstometrics.podAnnotations, and the Service port is namedhttp(port 80) when TLS is off. - MCP
ctx.sample()/ctx.list_roots()called right afterinitialize, before the client had opened itsGET /mcpstream, sent the request into nothing and timed out; they now wait for the stream within the same timeout. SDK clients open that stream in the background, so this made the conformance suite'stools-call-samplingscenario fail about one run in three. - Release workflow: the docs-site job builds on Node 24 (Astro needs ≥ 22.23.4; the runner's Node 22 was older, so 18.1.0's site update failed).
18.1 18.1.0 — 2026-10-26
18.1.0 — 2026-10-26
Added
- brotli and zstd compression (#7): responses are compressed in the coding
the client prefers by
Accept-Encodingq-values (br,zstdorgzip), at the fast levels peers use per response (brotli 4, zstd 3); static files are compressed once per version per coding (brotli 6, zstd 6) and cached, and precompressedapp.js.br/.zst/.gzsiblings are served when at least as new as the file.compression::apply_compression,negotiate,encode,Encoding,Level; Cargo featuresbrotliandzstd(default). New benchmark scenariostext-brandtext-zstd. - Reload on file change (#10):
watch = true(RWS_CONFIG_WATCH) reloads whenrws.config.tomlor a configured certificate or key changes, with the same validation asSIGHUP; covered byci/e2e/config_reload.sh. - Access log to a file (#9):
access_log(RWS_CONFIG_ACCESS_LOG) writes access-log lines to a file instead of stdout;access_log_max_sizerotates it by size (access.log→access.log.1…, keepingaccess_log_keep), andSIGUSR1reopens it for logrotate (only when a file is configured; otherwiseSIGUSR1keeps its default action). A hardened systemd unit is documented on the new systemd page. - Fuzz targets for WebSocket frames, DNS SRV responses, Redis replies and
Cookieheaders, and a request-smuggling seed corpus (CL+TE, conflicting or listedContent-Length, obfuscated or foldedTransfer-Encoding, bare-LF and oversized chunks) whose handling a test pins (#8).
Fixed
- WebSocket frames claiming a huge payload (#8).
WebSocket::read_frameallocated whatever length a client claimed (up to 2^64 − 1 bytes) before reading it, so one 14-byte frame could abort the process. Payloads are now read as they arrive and capped atWebSocket::MAX_FRAME_PAYLOAD(16 MiB);WebSocket::read_frame_limitedtakes another limit. - Redis replies (#8). The RESP reader allocated a bulk string at the
length the server claimed; bulk strings are now read as they arrive, capped
at 512 MiB (Redis's own maximum), reply lines at 64 KiB, and a connection
closed mid-reply is an error instead of reading as
+OK. - DNS SRV discovery (#8). A response whose SRV record ended inside its RDATA panicked while reading priority, weight and port; it is now an error.
- A compressed response kept the uncompressed body's strong
ETag, so a cache could not tell the representations apart; it now carries the coding ("x"→"x-gzip"), static files included. - An
Accept-Encodingparameter starting with a multi-byte character (gzip;aé) panicked while looking forq=, ending that connection (found by the newaccept_encodingfuzz target; the same code was in 17.x and 18.0.0).
18.0 18.0.0 — 2026-10-26
18.0.0 — 2026-10-26
Breaking
- The
rwsbinary runs one runtime per core (RWS_CONFIG_RUNTIME=per-core, Unix): one single-threaded runtime per core on its ownSO_REUSEPORTsocket, as nginx runs workers. On the fastest benchmark runners that is where rws trailed nginx on requests per second; on slower machines it costs more CPU per small request.runtime = "shared"/RWS_CONFIG_RUNTIME=sharedrestores 17.x behaviour; library applications staysharedunless they opt in. Headerfields areCow<'static, str>instead ofString. Build withHeader::new(name, value)or.into(); read with&*h.value/h.value.as_ref().- Default response headers: client hints (
Accept-CH,Critical-CH, the hints inVary) are opt-in withRWS_CONFIG_CLIENT_HINTS=true;VaryisOriginotherwise. Static files sendCache-Control: no-cache(RWS_CONFIG_STATIC_CACHE_CONTROL) instead ofno-store, plus a standardLast-Modified; every response has a standardDate.X-Frame-Options,Referrer-Policy,Permissions-Policyand the default CSP are opt-in withRWS_CONFIG_SECURITY_HEADERS=true(a CSP set withRWS_CONFIG_CSPis always sent), andDate-Unix-Epoch-Nanos/Last-Modified-Unix-Epoch-NanoswithRWS_CONFIG_NANOS_HEADERS=true. Request.bodyis arequest::Body(#31), not aVec<u8>: the bytes as before (it derefs to&[u8]), or a stream of a body still arriving. Build with.into()/Default::default();.to_vec()where aVec<u8>is wanted. See the migration page.- ACME renewal follows the certificate and the CA (#1). Certificates are renewed at two-thirds of their lifetime, or earlier when the CA's ACME Renewal Information (RFC 9773) suggests it, instead of 30 days before expiry — which would renew a 6-day certificate at once and leave a 45-day one (Let's Encrypt's default from 2028) a third of its life. Renewal orders name the certificate they replace (
replaces).RWS_CONFIG_ACME_PROFILEorders a certificate profile (classic,tlsserver,shortlived).RWS_CONFIG_ACME_RENEW_BEFORE_DAYShas no default now; set it to keep a fixed margin.AcmeConfig::renew_before_daysis anOption<i64>andAcmeConfighas aprofilefield. The renewal loop sendsSIGHUPonly after a renewal (it did after every check). - MCP sessions are bounded (#4): idle for an hour (
McpServer::session_ttl) or past 10 000 (max_sessions, least recently used first) a session is evicted with its subscriptions and SSE streams;DELETE /mcpends one; at most 1000 SSE streams (max_sse_clients, then503). A request carrying anMcp-Session-Idthe server doesn't know now gets404— the transport's signal to initialize again — instead of running with an empty context. - CORS allow-all is off by default (#59).
RWS_CONFIG_CORS_ALLOW_ALLdefaulted totrue, which echoed anyOriginwithAccess-Control-Allow-Credentials: true— any site could read a logged-in user's responses. With no CORS configurationrwsnow adds no CORS headers; list origins inRWS_CONFIG_CORS_ALLOW_ORIGINS, or setRWS_CONFIG_CORS_ALLOW_ALL=truefor the old behaviour. - HTTP/2 server: rws serves HTTP/2 with its own implementation
(
h2_server) instead of theh2crate; the hiddenh2_handlermodule is gone. Same conformance (h2spec 146/146), limits and behaviour; theh2crate stays as the proxies' HTTP/2 client. - RSA keys:
auth::verify_jwt_rs256andSamlIdpMetadata.signing_keytakersa_key::RsaPublicKey(wasrsa::RsaPublicKey); RSA keys under 2048 bits are rejected. Thersacrate (RUSTSEC-2023-0071) is no longer a dependency of the auth/SSO features.
Added
- MCP conformance: the official suite (
@modelcontextprotocol/conformance0.1.16, 2025-11-25 scenarios) runs on every push againstexamples/mcp_conformance.rs(ci/e2e/mcp_conformance.sh): 28 of 31 pass, the three elicitation scenarios are known failures (ci/mcp-conformance-baseline.yml). For it,McpContent::audio,McpContent::blocks(several items in one tool result) andMcpContent::blob(binary resources, sent asblob). Atools/callwith aprogressTokenfrom a client that acceptstext/event-streamis answered as an event stream — progress notifications, then the result — instead of sending progress to the separateGET /mcpstream, which a client may not have opened yet; progress without such a stream now goes only to the caller's session (it went to every connected session). - MCP gateway (#62):
mcp::gateway::McpGatewayputs one endpoint in front of upstream MCP servers — tools as<prefix>__<tool>,allow(identity, tools)rules (deny by default), upstream credentials set perUpstreamand never the caller's; JSON and event-stream replies, paginatedtools/list, session re-initialization; upstream failures areisErrorresults.McpServer::require_bearer_tokens(a token per named caller, seen as{"sub":…}inauth_claims) andMcpServer::tool_filter(per-request tool visibility) work on any MCP server.examples/mcp_gateway.rs; docs page MCP gateway. - Typed MCP tools (#61):
McpServer::typed_tool(name, description, |ctx, args: In| -> Result<Out, String>)(serde) derivesinputSchema/outputSchemafrom the types, deserializes the arguments and returnsstructuredContent.#[derive(JsonSchema)](macros) and theschema::JsonSchematrait produce the schemas, following#[serde]renames; attributes that would make them disagree are compile errors.examples/mcp_inventory.rsexposes an app's domain functions as REST routes and MCP tools with OAuth and live resource updates; docs page Build agent tools. rws-macros must be published (with the derive) before rust-web-server 18.0.0. If-Modified-Sinceanswers304for static files (when there's noIf-None-Match).[[upstream]] tls_ca_file/ReverseProxy::tls_ca_file: trust a private CA forhttps://upstreams.- Inline tables in
rws.config.tomlsettings (rate_limit = { max_requests = 5 }). RWS_CONFIG_OPEN_FILE_CACHE_STRICT=false: reuse a cached file's metadata for the cache window instead of checking it per request.mimallocfeature: therwsbinary allocates with mimalloc v3; release binaries and images are built with it — 4–6% less CPU per request, at a larger memory footprint (about 34 MiB under load instead of 9; up to ~120 MiB serving large files over TLS). Build without the feature for the smaller footprint.RWS_CONFIG_RUNTIME=per-core: one single-threaded runtime per core, each on its ownSO_REUSEPORTlistener (Unix) — more throughput on fast CPUs, more CPU per request on slow ones; the default staysshared.- Supply chain (#5): release binaries are built with
cargo auditable(cargo audit bin rwsworks on them), releases carry a CycloneDX SBOM, archives and images get GitHub build-provenance attestations, and images are signed keyless with cosign. CI runscargo deny check(advisories, permissive licenses only, crates.io sources only;deny.toml). - Streamed request bodies (#31): an application that answers
truefromApplication::streams_body(orAppWithState::stream_body(method, pattern)) getsrequest.bodyas a stream it reads while the upload arrives — a 512 MiB upload stays under 64 MiB of memory. HTTP/1.1 (plain and TLS) and HTTP/2 (the stream window is credited back as the handler reads); HTTP/3 and the HTTP/1.1-only build still read the body first.Middleware::accepts_streamed_bodylets a header-only layer pass it through.Storage::put_stream(key, reader, content_type)stores a stream: S3 as a multipart upload in 8 MiB parts (aborted on failure), local disk via a temporary file renamed into place — a 2 GiB HTTP upload streamed to an S3-compatible server grew peak memory by under 96 MiB. - MCP (#3): structured tool results (
McpContent::structured,McpServer::tool_output_schema→outputSchema/structuredContent), tool and server titles (tool_title,title) and icons (McpIcon,tool_icon,icon).tools/callarguments are checked against the input schema (an object,requiredproperties, propertytypes); a mismatch is anisErrortool result rather than reaching the handler. Withrequire_oauth, the server publishes RFC 9728 protected-resource metadata at/.well-known/oauth-protected-resourceand its401carriesWWW-Authenticate: Bearer resource_metadata=…; the/.well-known/oauth-authorization-serverlook-alike document is gone. The server speaks protocol versions 2024-11-05 through 2025-11-25 (it advertised 2024-11-05 only and echoed any older string): an unsupported requested version is answered with 2025-11-25, an unsupportedMCP-Protocol-Versionheader gets400, and JSON-RPC batches are refused for sessions on 2025-06-18 or later.
Fixed
- MCP (#60):
extract_argreturns numbers and booleans (it read only strings), so the binary'sset_maintenance {"enabled": true}andfeature_setdid nothing andrecent_requests/recent_errorsignoredn; thereload_configtool now reloads (it set a flag only the HTTP/1.1-only server reads) via the newconfig_reload::request_reload(). The built-in tools carry read-only/destructive hints (McpServer::tool_annotations), and the new Operate rws from an AI client page has the setup and playbooks. - Docs (#12): MCP sampling, roots and logging are marked deprecated by the 2026-07-28 MCP specification (they keep working); the MCP SSE stream is documented — and now tested — over HTTP/2 and HTTP/3, not only HTTP/1.1.
- A request head must arrive within 30 s of its first byte, else
408— a slow-drip client could hold a connection for weeks. H2ReverseProxy::read_timeout_mswas ignored; a silent HTTP/2 backend hung the request.- The reverse proxy sent the client's
Content-Lengthupstream next to its own (two headers — strict backends reject that, and it's a desync risk). It now sends one, drops headers named inConnection,TrailerandProxy-Connection, and appends the client address to an incomingX-Forwarded-Forinstead of sending a second one. CacheLayerno longer storesno-cacheresponses, responses toRangerequests, or responses that vary on a header outside its key.- A JWKS key that can't be used is skipped instead of failing verification.
- HTTP/2 (#6): resets the server sends because the client broke a stream's rules (a zero or overflowing
WINDOW_UPDATE, a badPRIORITY, frames on a closed stream) count toward the rapid-reset budget, closing the "MadeYouReset" hole (CVE-2025-8671) in rws's own HTTP/2 server; and a connection with nothing running that sends nothing for 30 s — a silent client, a half-sent header block or request body, a client that never opens the flow-control window — is closed withGOAWAY(NO_ERROR). It used to stay open forever. If-Modified-Since(new in 18.0) accepts the obsolete RFC 850 and asctime date forms as well as the IMF-fixdate (RFC 9110 §5.6.7); a client sending them always got the whole file.If-Rangewith a date (on top of 17.113.2's entity-tag handling): theRangeapplies when the date equals the file'sLast-Modifiedand that is at least a second old (a strong validator), else the whole file is sent.
Performance
On the benchmark runner, 1 KiB static files went from 49k to 126k requests/s
and the 1 KiB reverse proxy from 28k to 49k: open files, small
file contents and gzip output are cached per file version; one write per
response (writev for large bodies, sendfile with the head in the same
segment); header lists, dates and numbers built without allocation; request
and upstream-response heads parsed in one pass; HTTPS upstreams forwarded
without blocking a thread; access log buffered per thread (flushed every
100 ms). Files over TLS are read on the connection's task (13% less CPU and
about half the memory for large downloads), HTTP/2 is served by rws's own implementation (20–37% less CPU per request
than with the h2 crate), and release builds
allocate with mimalloc (4–6% less CPU, more memory). Details:
Benchmarks.
17.113 3 releases: 17.113.0 – 17.113.2
17.113.2 — HTTP conformance
Upgrading
Some fixes refuse or change what 17.113.1 accepted:
- An HTTP/1.1 request without
Host, with twoHostheaders, with a lower-case method (get), with a folded header line or with whitespace before a header's colon now gets400(#57). - An HTTP/1.0 connection now closes after each response unless the client sends
Connection: keep-alive(RFC 9112 §9.3; #57). - CORS origins match whole: an allow-list entry that relied on matching part of an origin (
example.comforhttps://app.example.com) now matches nothing — list each origin (#58). - Request paths are percent-decoded: a file whose name contains a literal
%is requested as%25(#55).
Fixed
- gzip no longer rewrites a partial body (#52). A
Rangerequest withAccept-Encoding: gzipgot the requested slice gzipped andContent-Rangerewritten to the compressed size (bytes=0-1200of a 3,700-byte file →Content-Range: bytes 0-37/37), which no client can reassemble. A206is now sent uncompressed (RFC 9110 §14.4). - multipart/byteranges framing (#53). A multi-range response had neither
Content-LengthnorTransfer-Encoding, so a keep-alive client couldn't tell where it ended and waited; the closing delimiter lacked its trailing--; and the boundary was the fixed stringString_separator, which broke the framing of any part that contained it. The response now carries aContent-Length, ends with--boundary--, and uses a boundary (Range::multipart_boundary) that occurs in none of the parts (RFC 9112 §6.3, RFC 2046 §5.1.1). The legacyResponse::_parse_responsereads the boundary fromContent-Typeand no longer loops forever on a body without a closing delimiter. - Bodiless responses carry no body or Content-Length (#54).
1xx,204and304responses must have no content (RFC 9110 §6.4.1, §15.3.5):OPTIONSon a static file answered204withContent-Lengthand, over HTTP/2, aDATAframe. Every writer now drops the body (buffered, file or pipe) andContent-Length/Transfer-Encodingfor those statuses (Response::drop_content_for_status). And a200toOPTIONSnow sends its body: it used to announce it withContent-Lengthand then drop it, so the client waited for bytes that never came. - The static request path is percent-decoded (#55). Files were looked up by the raw request target, so
GET /my%20file.txtwas a404formy file.txt, and the directory listing's (correctly encoded) links to such names were dead. The path is now decoded once, before the web-root and hidden-file checks of #43 (so/%2e%2e/is refused like/../);%2520stays a literal%20. ARangerequest for a name containing a space, quote,&,|or;no longer gets416(the file reader refused such paths), and the general static path finds escaped names'ETag. - If-None-Match is a list, compared weakly (#56). Only a header equal to the file's
ETaggave304: a client sending several tags ("a", "b") or the weak form (W/"…") always got the whole file again (RFC 9110 §13.1.2). - If-Range is honored (#56). It was ignored: a client resuming a download with
If-Rangegot206with bytes of the file as it is now, even after the file changed. ARangenow applies only whileIf-Rangestrongly matches the currentETag; otherwise the whole file is sent with200(RFC 9110 §13.1.5). - Range: one satisfiable range is enough; 416 names the length (#56).
bytes=0-9, 99999-on a small file was a416because of the second range; unsatisfiable ranges are now skipped and416is sent only when none can be served — withContent-Range: bytes */<length>, which it lacked (RFC 9110 §14.2, §15.5.17). - 405 with Allow for files (#56).
POST/PUT/DELETEon an existing static file got404, which says the resource doesn't exist; it now gets405 Method Not AllowedwithAllow: GET, HEAD, OPTIONS(RFC 9110 §15.5.6). - Strict HTTP/1.1 request heads (#57). Requests without
Hostor with two, a lower-case method,HTTP/0.9/HTTP/2.0in the request line, folded header lines, whitespace before a header's colon, and header names that aren't tokens are answered400— each is a way forrwsand a proxy in front of it to read the same bytes differently (RFC 9112 §2.2–§3.2, §5.1).Connectionis evaluated token by token:Connection: close, TEused to keep the connection open; an HTTP/1.0 connection now stays open only withConnection: keep-alive.Request::parseitself stays lenient for library callers; the checks are in the connection loops (server::framing::validate_head). - CORS: whole-origin matching; exposed headers on the response (#58). An origin was allowed when it was a substring of the configured list, so with
https://app.example.comlisted,https://app.example.co(andhttps://pp.example.com) got CORS headers — with credentials when those are on. Origins are now compared whole (Cors::origin_is_allowed).Access-Control-Expose-Headerswas sent only on the preflight, which browsers ignore; it is now on the actual response.
17.113.1 — security patch
Fixes from the 2026-10-25 security review. Upgrade from 17.113.0.
Security
- Proxy: interim responses (#48). A
1xxfrom an upstream (100 Continue,103 Early Hints) was taken as the final response; the real response stayed in the pooled connection and was delivered to the next request on it — possibly another client's. Both forwarders now read past interim responses (at most 16;101 Switching Protocolsis still final). - Static files stay inside the web root (#43). A request path with
..segments (/../../etc/passwd) was resolved against the working directory and could read any file the process could; such paths now get404, and a symlink inside the root that points outside it is not followed. Dot-files and dot-directories (.git/,.env) are no longer served; setRWS_CONFIG_SERVE_DOTFILES=trueto serve them again (.well-known/is always served). - Byte-range limits (#46). Each range of a multi-range request was read into memory separately:
Range: bytes=0-,0-,0-,…(thousands of ranges in a 64 KiB head) made one request hold thousands of copies of a file. Overlapping ranges are now merged, and more than 16 ranges are answered with the whole file as one range (RFC 9110 §14.2). - No CR/LF in header lines (#47). The HTTP/1.1 writers copied header names, values and the reason phrase verbatim, so a value carrying user input (a redirect target, an upstream header) could inject headers or a second response; CR and LF now become spaces. The mailer does the same for
Subject,To,Cc,Reply-ToandFrom, and refuses an address containing CR, LF,<or>(it went intoMAIL FROM/RCPT TOas is). HTTP/2 and HTTP/3 already refused such values. - CacheLayer: never cache private responses (#49). The cache is keyed by URL, so a response built from one user's
CookieorAuthorizationwas served to the next visitor, aSet-Cookieresponse was replayed to everyone, aRangeresponse was served for the whole resource, and a streamed response was replayed with an empty body. Requests withAuthorization,CookieorRangenow skip the cache, and responses withSet-Cookieor a streamed body aren't stored. Therwsbinary wraps every response inCacheLayer. - Proxy routes match a normalized path (#50). Routes matched the raw request path, so
/%61dmin,//adminor/x/../adminskipped a route protecting/admin/*(auth, IP filter, rate limit) and reached the backend through a catch-all route, which then saw/admin. Paths are now normalized before matching and sent upstream normalized (unreserved escapes decoded, a stray%encoded, repeated slashes collapsed, dot segments resolved), andhostmatches ignoring case and port. /mcpneeds a token (#44). Therwsbinary served its MCP tools — config reload, blocklist, maintenance mode, server introspection — to anyone who could reach the port unlessMCP_TOKENwas set. Now they're mounted only with a non-emptyMCP_TOKEN, and/mcpsits behind the access log, IP blocklist and global rate limit. InMcpServer: a request with anOriginheader not listed in the new.allowed_origins(...)gets403(browser cross-site requests and DNS rebinding;MCP_ALLOWED_ORIGINSin the binary), aPOSTthat isn'tapplication/jsongets415, an empty bearer token refuses every request, and tokens are compared in constant time.- Private keys out of the web root (#45). With no paths configured, ACME stored
cert.pem,key.pemandacme_account.keyin the working directory — the web root — so both private keys could be downloaded. They now default to.rws/acme/(keys0600, directory0700, never served); on upgrade, files at the old default paths are moved there. The static server no longer serves*.pem,*.keyorrws.config.tomlanywhere. If you ran ACME without explicit paths, rotate the certificate key and the ACME account key. The Docker image already kept them in/data.
17.113.0 — 2026-10-24
- Proxy: pooled keep-alive upstream connections on every HTTP/1.1 path, pooled HTTPS backends, non-blocking forwarding to plain-HTTP upstreams; hot reload of routes, upstreams and
[middleware]onSIGHUP. rws --checkvalidates a config file; fixed inline middleware tables being ignored (an auth bypass), global[middleware], IPv6 IP filters.- HTTP/1.1: request heads read across reads (up to 64 KiB), pipelined requests kept, chunked bodies decoded.
- Static files: open-file cache,
sendfilefor plain-TCP downloads, quick requests run on the event loop. - Compression skips small, incompressible and already-encoded bodies.
- Docker image no longer crashes at startup; published to Docker Hub with a smoke test and a
/datavolume.
17.112 17.112.0 — 2026-10-24
17.112.0 — 2026-10-24
- RFC 9110 byte ranges;
Content-Rangeonly on206, now over HTTP/2 and HTTP/3 too. - Every setting works from
rws.config.toml; unknown keys warn instead of vanishing. - Config-driven proxy auth fails closed instead of serving the route unauthenticated.
- Automatic HTTPS (ACME) from one config section, verified against Pebble.
- The documented proxy config no longer returns
502; proxied responses no longer break HTTP/2.
17.111 17.111.0 — 2026-10-23
17.111.0 — 2026-10-23
- Prebuilt binaries, Homebrew tap, GHCR image,
cargo binstall;rws --version/--help.
17.110 17.110.0 — 2026-10-23
17.110.0 — 2026-10-23
- Directory listing for static directories without
index.html; opt-in SPA fallback. - Ingress: TLS to the API server, watch API,
pathType: Exact, IngressClass filtering. - Service discovery: Consul, etcd, Docker labels, DNS SRV / weighted DNS.
- Canary: smooth weighted round-robin, live weight updates; circuit breaker wired into
ReverseProxy. - Secret references (
vault://,aws-sm://,azkv://);Response::json/Response::text. - WebAssembly guest component (
wasm32-wasip2) with outbound HTTP and streaming bodies. - Helm chart.
Earlier Earlier
Earlier
See the GitHub releases and the git tags.