the-benchmarker/web-frameworks

This system is a comprehensive benchmarking suite designed to compare the performance of web frameworks across a wide variety of programming languages and runtimes. It provides standardized, containerized implementations of HTTP servers that expose a consistent set of RESTful endpoints for throughput and latency testing. The infrastructure includes a modular benchmarking harness that measures metrics such as CPU saturation, memory usage, and latency percentiles under load, storing results in a database for analysis.

72 changes.

The project focused on significantly expanding its benchmark suite by adding implementations for numerous web frameworks across languages such as Go, JavaScript, Crystal, Rust, and PHP. Concurrently, it standardized the infrastructure by upgrading runtime versions, introducing cluster support for JavaScript engines, and refining configuration and Dockerfile structures to ensure consistent, high-performance benchmarking environments.

65 changes.

This period focused on significantly expanding the benchmark suite by adding support for numerous new web frameworks across languages such as Go, Rust, Nim, F\#, and V, while also updating existing implementations to newer versions. Concurrently, the project overhauled its benchmarking infrastructure, replacing the previous automation with a modular task system that introduced precise measurement probes for CPU saturation, latency, and memory usage.

57 changes.

This period focused on expanding the project's benchmark suite by adding implementations for a wide variety of web frameworks across numerous programming languages. New entries were introduced for languages including JavaScript, Rust, Nim, Crystal, D, Zig, and others, often featuring cluster support and multi-process scaling. The work primarily involved scaffolding basic HTTP server examples to facilitate performance comparisons across different ecosystems and runtimes.

17 changes.

This period focused on expanding the benchmark suite by adding implementations for numerous new web frameworks and runtimes across Rust, JavaScript, Nim, Luau, and C. Each entry introduces a standardized HTTP server structure with consistent routing and clustering configurations to facilitate performance testing.

The javascript/0http location now includes a new example application using the 0http framework (version 5.1 as per config.yaml). The entry points (app.js and app.mjs) demonstrate basic routing for GET and POST requests. Additionally, a new cluster.mjs file implements multi-process clustering using Node.js's cluster module, including graceful shutdown handling for SIGINT and SIGTERM signals.

javascript/0http, javascript/h3 · high confidence

Introduces the 0http-bun framework (v1.3) for Bun-based HTTP applications. The entry point (app.ts) sets up a basic router with GET and POST endpoints served on port 3000 with port reuse. A new cluster.ts file enables multi-core scaling by spawning worker processes equal to the number of available CPU cores and handles graceful shutdown via SIGINT and SIGTERM signals.

javascript/0http-bun · high confidence

This location introduces a new ASP.NET MVC example for C\#, providing a minimal web API setup. The implementation includes a Controller with endpoints for home, user retrieval by ID, and user creation, alongside a Program.cs that configures Kestrel, logging, and controller mapping. The configuration specifies the framework version as 10.0.

csharp/aspnet-mvc · high confidence

Added a new Java benchmark using the ActiveJ framework (version 5.5) that implements an HTTP server with routing for root, user ID, and user list endpoints, configured to listen on port 3000 and utilize available processors for worker threads.

java/activej · high confidence

This change introduces a new AdonisJS HTTP server implementation (version 9.0) that includes a primary application entry point (app.js/app.mjs) and a cluster manager (cluster.mjs). The application sets up a basic HTTP server with routes for root, user lookup, and user creation, while the cluster manager enables multi-process handling by forking workers based on available CPU cores and properly handling SIGINT/SIGTERM signals for graceful shutdown.

javascript/adonisjs-http · high confidence

Introduces a new C-based web server framework (Agoo-C v0.7) to the benchmark suite. The addition includes a Makefile for building the project, a configuration file specifying the framework version and download/build steps, and a sample C application (simple.c) that demonstrates basic HTTP routing and server initialization.

c/agoo-c · high confidence

A new ApplicationController has been added to the Amber application, providing base methods for handling index, get, and create actions.

crystal/amber/src/controllers · high confidence

The PHP directory now includes four new framework implementations: Antidot (v2.0) using the ReactPHP engine, Aplus App (v25.1) and Aplus One (v25.1) from the Aplus Framework ecosystem, and BasicPHP (v0.9), a frameworkless library. These additions expand the available PHP runtime options for benchmarking and testing.

php · high confidence

Introduces a new benchmark setup for the Armeria framework, including a configuration file (config.yaml) that defines the build process using Maven and specifies the resulting benchmark JAR, alongside a Java source file (BenchmarkApplication.java) that implements a basic HTTP server with endpoints for listing, retrieving, and creating users.

java/armeria · high confidence

New example applications have been added for the Phoenix and Plug frameworks using the Bandit HTTP adapter. These examples demonstrate how to configure and run servers with Bandit, including specific setup for the \plug\_bandit\ adapter which listens on port 3000, alongside existing Cowboy-based examples for comparison.

(repo-wide) · high confidence

Added a new Beego v2.3 example application in the go/beego directory, including a configuration file specifying the framework version and a main.go file demonstrating basic HTTP routing for GET and POST requests on port 3000.

go/beego · high confidence

Introduces a new application in the javascript/blaze-bun directory that serves as a REST API using the Blaze framework (v4.4) on the Bun runtime. The app exposes core and user services with endpoints for listing items, finding by ID, and creating new entries. It is configured to run as a multi-process cluster, spawning one worker per CPU core via the main cluster script, which handles graceful shutdown on SIGINT and SIGTERM signals.

javascript/blaze-bun · high confidence

Introduces the Brahma-Firelight framework (v1.5) targeting the Bun runtime. The implementation includes a basic HTTP application with GET and POST routes, alongside a cluster management script that spawns worker processes based on available CPU cores and handles graceful shutdown via SIGINT and SIGTERM signals.

javascript/brahma-firelight · high confidence

Introduces a new JavaScript/Bun framework implementation that utilizes Bun's built-in HTTP server. The provided cluster.ts script demonstrates a multi-worker setup using Node's cluster module to fork workers across available CPU cores, with each worker running a Bun server on port 3000. The configuration (config.yaml) specifies the framework source as oven-sh/bun version 1.2.5, and the project includes a bun.lock file pinning @types/bun and related type definitions.

javascript/bun · high confidence

Introduces a new C\# API implementation based on the Carter framework (version 10.0). The application configures a Kestrel web server with logging disabled and the server header removed, registers the Carter routing module, and exposes two endpoints: a GET route at / returning a completed task, and a GET/POST route at /user/{id} and /user respectively.

csharp/carter · high confidence

Introduces a new C\# implementation of the CodeBehind framework, featuring a minimal ASP.NET Core application structure. The entry includes a Program.cs that registers the CodeBehind services and middleware, a config.yaml specifying the Elanat website framework version 4.7, and sample controllers (Home and User) that inherit from CodeBehindController to handle page loads and route parameters.

csharp/codebehind, csharp/genhttp · high confidence

Added a new benchmark adapter for the CPS HTTP framework (version 2.0), implementing the standard three-route contract (GET /, GET /user/{id}, POST /user) using a multithreaded architecture. The implementation utilizes a work-stealing runtime with one I/O shard per worker, where each shard owns its own router, event loop, and listener, distributing accepts via SO\_REUSEPORT to avoid a shared scheduler on the HTTP data path. The server is configured with Nim's ARC memory manager, danger mode, and native CPU tuning for performance.

nim/cps-http · high confidence

Added the CWIST framework (v3.7) to the benchmark suite, including the configuration file (config.yaml) and the application source code (main.c). The implementation defines a C application that listens on port 3000 and supports three endpoints: GET / returning an empty 2xx response, GET /user/:id returning the path parameter as the body, and POST /user returning an empty 2xx response. The build configuration specifies dependencies such as libzstd, libbrotli, libcurl, and others, and compiles the binary using gcc with specific include and library paths.

c/cwist · high confidence

This location introduces a new example application demonstrating how to integrate the ChubbyTS framework with uWebSockets.js. The entry point (app.ts) configures the ChubbyTS application with error handling, route matching, and specific GET/POST routes, then bridges uWebSockets.js HTTP requests to the ChubbyTS/Undici server layer. A cluster manager (cluster.mjs) is added to support multi-process deployment with graceful shutdown handling for SIGINT and SIGTERM signals. Configuration files (config.yaml, tsconfig.json) and a .gitignore are also included to define the build environment and exclude artifacts.

javascript/chubbyts-uwebsockets · high confidence

Introduces a new Clojure-based benchmarking engine using the AppsFlyer Donkey framework (v0.5.2) and Clojure 1.12.6. The server exposes three HTTP endpoints on port 3000: a root handler returning an empty 200 response, a GET /user/:id route returning the ID as plain text, and a POST /user route returning an empty 200 response. It is built with Leiningen into an uberjar and configured to run with specific JVM options for performance tuning.

clojure/donkey · high confidence

Added a new benchmark implementation for the Pedestal web framework. The project uses Clojure 1.12.6 with Pedestal Service and Jetty versions 0.8.1, configured to run on JDK 21 via Leiningen. It defines a simple HTTP service with routes for the root, user creation, and user retrieval, serving as a baseline for performance testing.

clojure/pedestal · high confidence

Added two new Elixir HTTP server implementations based on the Cowboy library: a standard Cowboy handler and a Cowboy Stream handler. The standard implementation (\elixir/cowboy\) configures a supervisor to start a Cowboy listener on port 3000 with specific connection limits and routes requests to a module handling GET \/\, GET \/user/:id\, and POST \/user\. The stream implementation (\elixir/cowboy\_stream\) similarly sets up a listener but uses the \:cowboy\_stream\ behavior, implementing the required \init\, \data\, \info\, \terminate\, and \early\_error\ callbacks to handle HTTP/1.1 requests with streaming support, routing the same endpoints.

_elixir/cowboy, elixir/cowboy\stream · high confidence

A new Objective-C application named \server\_objc\_criollo\ has been added to the \objc/criollo\ directory. This macOS app uses the Criollo framework to run an HTTP server on port 3000, exposing a root endpoint, a parameterized user route (\/user/:id\), and a POST \/user\ endpoint. The project includes the necessary Xcode project configuration, CocoaPods dependencies (Criollo and CocoaAsyncSocket), and source files to build and run this server component.

objc · high confidence

A new demo application for the Crystal Athena Routing framework has been added to the repository. This entry point demonstrates how to configure and run an HTTP server using the \athena-routing\ shard, including setting up route handlers for GET and POST requests and binding the server to port 3000.

crystal/athena-routing · high confidence

Introduces a new Crystal application scaffold using the Grip framework (version 5.0). The setup includes a basic HTTP server with an index controller and a user controller handling GET and POST requests, configured to run on port 3000 in production mode.

crystal/grip · high confidence

Introduces a new Crystal-based HTTP server component that utilizes the \tbrand/router.cr\ library (version 0.2) for routing. The server exposes endpoints for the root path, user retrieval by ID, and user creation, while explicitly disabling logging output. It binds to port 3000 and configures the fiber execution context to scale with the number of available CPU cores.

crystal/router.cr · high confidence

Introduces a new Crystal application scaffolded with the Marten web framework (version 0.7). The project includes a basic HTTP server configuration, route definitions for root, user creation, and user detail endpoints, and handler implementations for these paths. It also sets up project dependencies via shard.yml and configures runtime settings such as host, port, and logging levels.

crystal/marten · high confidence

Added a new D language example using the Lighttp web framework. The entry includes configuration files (config.yaml, dub.json) and source code (app.d) demonstrating a basic server setup with routing for GET and POST requests on endpoints like / and /user.

d/lighttp · high confidence

Introduces a new D language example application using the Vibe.d framework. The project includes a \dub.json\ configuration depending on \vibe-d\ version 0.10 and related HTTP modules, along with a \config.yaml\ specifying version 1.3. The source code (\source/app.d\) implements a multi-threaded HTTP server listening on port 3000, featuring routes for handling root requests and user data retrieval via GET and POST methods, optimized for LDC with native CPU settings.

d/vibed · high confidence

This change introduces new Dart benchmark implementations for the Jet, Relic, Shelf, and Spry frameworks, each provided in both VM and AOT (Ahead-of-Time) variants. The diff adds specific server code for each framework (e.g., \server.dart\ files) and corresponding configuration files (\config.yaml\) that define the framework source (GitHub/website) and version (e.g., Spry 8.1, Shelf 1.4, Relic 1.1, Jet 0.1). It also includes Dockerfiles (\aot.Dockerfile\, \vm.Dockerfile\) targeting Dart 3.13, a \.gitignore\ for Dart tooling, and cluster scaling logic using Dart isolates for multi-core utilization in the Shelf and Spry implementations.

dart · high confidence

Introduces a new benchmark entry for the Drogon C++ web framework. The change adds the necessary build configuration (CMakeLists.txt, FindDrogon.cmake, FindJsoncpp.cmake), application code (main.cc, UserCtrl controller, SyncPlugin), and configuration files (config.json, config.yaml) to compile and run a benchmark using Drogon version 1.9.13.

cpp/drogon · high confidence

Added new example implementations for the Elysia framework (version 1.4) supporting both Bun and Node.js runtimes. The Bun example (javascript/elysia-bun) includes a basic application and a cluster manager that spawns workers using Bun's spawn API with graceful shutdown handling for SIGINT and SIGTERM. The Node.js example (javascript/elysia-node) provides a similar setup using Node's native cluster module and the @elysiajs/node adapter, also with proper signal handling for graceful shutdown.

javascript/elysia-bun · high confidence

Introduces a new benchmark entry for the Express.js framework (v5.2) running on the Bun engine. The implementation includes an application entry point that disables the 'X-Powered-By' header and ETag generation, and a cluster manager that spawns worker processes based on available CPU cores while handling SIGINT and SIGTERM signals for graceful shutdown.

javascript/express-bun · high confidence

Introduces a new F\# sample application using the Falco web framework. The project includes a Program.fs file that sets up an ASP.NET Core web application with routing for user endpoints and a root path, along with a config.yaml file specifying the framework version as 5.0.

fsharp/falco · high confidence

Introduces a new F\# web server example using the Frank framework. The application defines three HTTP endpoints: a home page at '/', a user ID retrieval endpoint at '/user/{id}', and a user creation endpoint at '/user'. It is configured to use Kestrel with the server header disabled and logging providers cleared.

fsharp/frank · high confidence

Added support for the Fast web framework running on Deno. This includes a new application entry point (app.ts) that initializes the Fast framework (version 6.0.0-alpha.1) and defines basic routing for GET and POST requests, along with a configuration file (config.yaml) declaring the framework, its version, and the required Deno engine.

javascript/fast · high confidence

Introduces a new C\# sample application using the FastEndpoints micro-framework (v7.1). The sample configures a minimal web API with logging disabled to optimize performance, exposing endpoints for retrieving a user by ID and creating a new user.

csharp/fastendpoints · high confidence

Introduces a new Fastify-based application for the javascript/fastify location, including the main server entry point (app.mjs) and a cluster manager (cluster.mjs) that spawns workers across available CPU cores and handles graceful shutdown via SIGINT/SIGTERM signals. The implementation exposes basic GET and POST endpoints on port 3000 and includes a .gitignore file to exclude node\_modules and package-lock.json.

javascript/fastify · high confidence

Introduces a new sample application demonstrating Fastify (v5.12) running on the Bun runtime. The app exposes basic HTTP endpoints and includes a cluster implementation that spawns worker processes using Bun's spawn API, with signal handling for graceful shutdown.

javascript/fastify-bun · high confidence

Added a new FeathersJS example application located in the javascript/feathersjs directory, featuring both CommonJS (app.js) and ES Module (app.mjs) entry points that serve basic user endpoints on port 3000. The example also includes a cluster implementation (cluster.mjs) that utilizes Node.js clustering to spawn workers across available CPU cores and handles graceful shutdown via SIGINT and SIGTERM signals. Configuration indicates the example targets FeathersJS version 5.0.

javascript/feathersjs · high confidence

Added new example applications for the Foxify, Polka, and Polkadot JavaScript frameworks, each including CommonJS (app.js) and ES Module (app.mjs) variants. These examples demonstrate basic routing and include a cluster.mjs entry point that utilizes Node's cluster module to spawn workers based on available CPU cores, with graceful shutdown handling for SIGINT and SIGTERM signals.

javascript/foxify, javascript/polka, javascript/polkadot · high confidence

Added a new JavaScript framework implementation for Fyrejet version 4.0. This includes standard HTTP server examples using both CommonJS (app.js) and ES Modules (app.mjs) syntax, featuring basic routing for GET and POST requests with specific security headers disabled (etag, x-powered-by). Additionally, a cluster management script (cluster.mjs) was added to handle multi-process scaling using Node.js cluster API, including graceful shutdown handling for SIGINT and SIGTERM signals.

javascript/fyrejet · high confidence

Added a new example in go/nethttp demonstrating the Go 1.22 net/http package's enhanced routing capabilities, including method-specific patterns and path parameters.

go/nethttp · high confidence

Added a new Go example demonstrating the R2 web framework (v0.3). The entry includes a configuration file specifying the framework source and version, and a main.go file that sets up an HTTP server on port 3000 with routes for handling GET requests on the root and user ID paths, as well as a POST request for user creation.

go/gorilla-mux, go/r2 · high confidence

Introduces a new Go-based RTE (Runtime Environment) service component. This includes a configuration file defining the framework source and server address, and a main entry point that initializes an HTTP server using the 'jwilner/rte' library to handle basic routing for root and user endpoints.

go/rte · high confidence

A new Go-based example application using the Tango web framework (version 0.6) has been added to the go/tango directory. This includes a configuration file specifying the framework source and a default port of 3000, along with a main.go file that demonstrates basic HTTP routing for GET and POST requests with logging and recovery enabled.

go/air, go/tango · high confidence

Introduces a new Go-based router implementation using the fasthttp library. This includes a configuration file specifying the fasthttp engine and version 1.5, along with a main.go file demonstrating basic HTTP routing (GET and POST) on port 3000.

go/router · high confidence

Introduces a new Go-based example application in the go/gorouter directory that demonstrates the usage of the gorouter library (version 4.5). The included main.go file sets up an HTTP server on port 3000 with routes for the home page, a user creation endpoint, and a parameterized user ID lookup, while config.yaml specifies the framework version and wiki link.

go/gorouter · high confidence

Added a new example application demonstrating the usage of the julienschmidt/httprouter library (version 1.3). The application sets up a web server on port 3000 with routes for the home page, user creation, and retrieving a user by name.

go/httprouter · high confidence

Introduced a new Go implementation for the Aurora engine, including the main entry point, server configuration, and routing logic. The engine is configured to listen on port 3000 and exposes basic REST endpoints for retrieving and creating user resources.

go/aurora · high confidence

Introduces two new Goravel application templates, \go/goravel-fiber\ and \go/goravel-gin\, providing the core structure for building Go web applications. Each scaffold includes the standard Goravel directory layout (controllers, routes, providers, config) and a basic API controller with endpoints for listing, showing, and creating users. The \goravel-fiber\ variant configures the HTTP driver to use \github.com/gofiber/fiber/v2\ and \github.com/gofiber/template/html/v2\, while the \goravel-gin\ variant configures the driver to use \github.com/gin-gonic/gin\ and its default template engine. Both setups register the respective driver service providers (\fiber.ServiceProvider\ and \gin.ServiceProvider\) and wire up the routing facade to start the HTTP server on port 3000.

go/goravel-fiber, go/goravel-gin · high confidence

Introduces a new Gotham-based web server implementation in the rust/gotham location. The application listens on port 3000 and exposes three endpoints: a GET / route returning an OK status, a POST /user route returning an OK status, and a GET /user/:id route that extracts and returns the user ID from the path.

rust/axum, rust/gotham · high confidence

A new Nim-based HTTP server component named GuildenStern has been added to the product. It provides a basic HTTP service listening on port 3000 that handles GET requests to the /user/ path by echoing the user ID extracted from the URI. The server is configured to run with 100 threads and uses the lvlNone logging level.

nim/guildenstern · high confidence

Added benchmark configurations and server implementations for the Guile web framework, covering both the 'fibers' and 'guile-web' variants. The new files define build dependencies (including guile-3.0 and guile-fibers) and implement HTTP handlers that respond to GET and POST requests on specific paths, enabling performance comparison between the two Guile-based web approaches.

guile/fibers · high confidence

This change introduces a new Hapi.js implementation for the JavaScript benchmark suite. It includes application entry points for both CommonJS (app.js) and ES Modules (app.mjs) that define standard HTTP routes (GET /, GET /user/{id}, POST /user) on port 3000. Additionally, a cluster manager (cluster.mjs) is added to spawn worker processes based on available CPU cores, with proper handling for SIGINT and SIGTERM signals to ensure graceful shutdown. The configuration file (config.yaml) specifies the framework version as 21.4.

javascript/hapi · high confidence

New example projects for the Servant and Scotty web frameworks have been added to the repository. The Servant example demonstrates a generic API server using \servant-0.20\ with endpoints for retrieving, echoing, and posting user data, while the Scotty example provides a basic HTTP server on port 3000 with routes for root, user ID capture, and user creation.

haskell/servant · high confidence

Introduces a new Helidon SE-based web server application that serves as a demo or template. The application includes a main entry point starting a web server on port 3000, an index service handling the root path, and a user service exposing a POST endpoint at /user and a GET endpoint at /user/{id}. Configuration is managed via application.properties and a build configuration file (config.yaml) specifying Maven build steps and the resulting binary.

java/helidon-se · high confidence

Added new example implementations for the Hono web framework, specifically targeting Node.js and Bun runtimes. The Node.js entry point uses the \@hono/node-server\ adapter to serve the application, while the Bun entry point exports the standard fetch handler. Additionally, cluster management scripts were added for both runtimes: the Node.js version utilizes the native \cluster\ module with graceful shutdown handling for SIGINT/SIGTERM, and the Bun version spawns multiple worker processes using \bun spawn\ with corresponding signal handling. The configuration files indicate support for Hono version 4.13.

javascript/hono · high confidence

This location introduces a new HyperExpress-based web server implementation, providing both CommonJS (app.js) and ES Module (app.mjs) entry points that serve basic routes on port 3000. It also includes a cluster manager (cluster.mjs) that spawns worker processes based on available CPU cores and handles graceful shutdown via SIGINT/SIGTERM signals. The configuration (config.yaml) specifies the use of the HyperExpress framework (version 7.0) with the uWebSockets engine.

javascript/hyper-express · high confidence

Introduces a new Rust-based HTTP server in the \rust/hyperlane\ crate that listens on port 3000. The server implements three routes: a root endpoint (\/\), a user list endpoint (\/user\), and a user detail endpoint (\/user/{id}\) that returns the ID parameter in the response body, all returning HTTP 200 status codes.

rust/hyperlane · high confidence

Introduces a new Ignisia framework starter that includes a basic application setup and multi-process cluster management. The application defines standard routes and listens on port 3000 with port reuse enabled. To support high concurrency, the starter spawns worker processes using Bun, one per available CPU core, and implements graceful shutdown handling for SIGINT and SIGTERM signals to ensure all workers are terminated cleanly.

javascript/ignisia · high confidence

Introduces a new Java implementation using the Blade web framework. The application listens on port 3000 and exposes three endpoints: a root path returning an empty response, a user lookup by ID (returning the ID or a 400 error if invalid), and a user creation endpoint. The project is configured to require Java 11 and uses the Blade library for routing.

go/aero, java/blade · high confidence

Introduces a new benchmark configuration using the Jersey 3.1 framework on the Grizzly2 HTTP server. The setup includes a Maven build process that produces a shaded JAR, serving JAX-RS resources (GET, POST, and path-parameter endpoints) on port 3000.

java/jersey3-grizzly2 · high confidence

A new benchmark application has been added for the Jooby framework (version 4.5), providing a reference implementation for performance testing. The entry includes the application source code (App.java) which exposes basic HTTP endpoints and utilizes the Netty server with event-loop execution mode, along with the necessary configuration (config.yaml) and build artifacts (.gitignore) to support the benchmark.

java/jooby · high confidence

The Julia HTTP.jl framework is now available, configured to use version 2.0. This addition includes a default server implementation that listens on port 3000 and provides basic routing for GET requests to the root and user endpoints, as well as a POST endpoint for user creation.

julia/http · high confidence

Introduces a new Julia-based example application using the Merly framework (v1.0.2). The entry includes the necessary project configuration files (Project.toml, Manifest.toml), a dependency resolution script (deps.jl), and a server implementation (server.jl) that defines basic HTTP routes for serving content and handling user data, running on port 3000.

julia/merly, rust/actix · high confidence

Added support for the Mongoose.jl web framework (version 0.3) to the Julia environment. This includes a configuration file pointing to the AbrJA/Mongoose.jl repository, a Project.toml declaring the dependency and compatibility constraints, and a server.jl script that initializes a Mongoose server on port 3000 with basic routing for root, user ID retrieval, and user creation endpoints.

(repo-wide) · high confidence

Introduces a new Koa-based sample application in the javascript/koa directory, including both CommonJS (app.js) and ES Module (app.mjs) entry points that define basic routing for user resources. The addition also includes a cluster.mjs module that manages worker processes across available CPU cores and handles graceful shutdown via SIGINT and SIGTERM signals, alongside standard configuration and gitignore files.

javascript/koa · high confidence

Introduces a new JavaScript example using the Koa framework (v3.1) running on the Bun engine. The application defines basic routing for user endpoints and implements a cluster setup that spawns worker processes based on available CPU cores, with proper handling of SIGINT and SIGTERM signals for graceful shutdown.

javascript/koa-bun · high confidence

Users can now deploy Perl applications using the Kossy (v0.63) and Dancer2 (v1.1) web frameworks. The update introduces new configuration and application templates for both frameworks, including specific dependency requirements in the cpanfile and entry-point definitions in the Dockerfile. Additionally, the base Perl runtime has been updated to version 5.45.

perl · high confidence

A new benchmark entry for the Jooby framework has been added, targeting version 4.5. The configuration defines a startup command using the Netty server with specific JVM flags (2GB heap, ParallelGC). The application code implements a basic Kotlin-based HTTP server using the Jooby API, exposing endpoints for a root path, a user lookup by ID, and a user creation POST request.

java/quarkus, kotlin/jooby · high confidence

Added a new Kotlin-based application scaffold using the Ktor framework (version 3.5 as specified in config.yaml). This includes the core application entry point, routing configuration for basic endpoints, and build infrastructure such as Gradle wrapper scripts and a .gitignore file. Logging is configured via logback.xml to suppress verbose output from Netty and Jetty dependencies.

(repo-wide) · high confidence

Introduces a new Kotlin-based Spring Boot benchmark implementation in the kotlin/spring directory. This includes a Spring Boot 3.4 application configured to run on port 3000 with virtual threads enabled, featuring REST endpoints for root access, user ID retrieval, and user creation, along with standard project configuration files like .gitignore and application properties.

kotlin/spring · high confidence

Added support for the Lapis Lua web framework, including a sample application with basic GET and POST routes, a configuration file for production deployment on Nginx/OpenResty, and a YAML definition specifying the framework version (1.19) and build dependencies.

lua/lapis · high confidence

Added the core application structure for both Laravel and Lumen frameworks, including the HTTP and Console Kernels, exception handlers, and base controllers. This scaffolding provides the foundational entry points for request handling, command scheduling, and error management in new PHP applications.

php/laravel-s-laravel, php/laravel-s-lumen · high confidence

Added a new language definition for Luau (version 1.0.0) that uses the Lute framework as the default engine. The configuration sets up a Dockerfile to build a container with Lute v1.0.0, and includes a sample server implementation in \serve.luau\ that listens on port 3000, handling GET requests for \/user/\*\ paths and POST requests to \/user\. The \server.luau\ entry point spawns multiple threads to run the server, leveraging the system's thread count.

luau · high confidence

The Lucky framework integration now includes basic API action stubs in \crystal/lucky/src/actions/api\_action.cr\. These define endpoints for listing home content, creating users, and showing user details, all configured to return plain text responses.

crystal/lucky/src/actions · high confidence

The Moleculer example now includes a cluster mode implementation (cluster.mjs) that spawns worker processes based on available CPU cores and handles SIGINT/SIGTERM signals for graceful shutdown. An application entry point (app.mjs) demonstrates a basic HTTP service setup using the HTTPServer mixin, and the configuration (config.yaml) updates the framework version to 0.15.

javascript/moleculer · high confidence

Added two new web framework implementations: MoroJS (version 1.8) and MoroJS Engine (version 1.1). The MoroJS implementation uses the @morojs/moro library with a native engine, configuring clustering via availableParallelism and disabling request tracking/logging. The MoroJS Engine implementation provides a raw HTTP server using @morojs/engine with static routes and SO\_REUSEPORT. Both include cluster management files and configuration.

javascript/morojs · high confidence

New example applications have been added for the Ohkami web framework, providing ready-to-run server implementations using the NIO and Tokio asynchronous runtimes. These examples demonstrate how to define basic routes (GET /, POST /user, GET /user/:id) and start the server on port 3000, giving users concrete templates for integrating Ohkami with these specific async runtimes.

rust/ohkami-nio, rust/ohkami-tokio · high confidence

Introduces a new NestJS-based project structure configured to run on the Bun runtime. This includes a configuration file specifying Bun as the engine with a PM2 bootstrap command, a NestJS CLI configuration, TypeScript build settings optimized for Bun (ESNext target, bundler module resolution), and a basic application entry point exposing GET and POST endpoints for user data.

javascript/durian.js · high confidence

Added a new example application in the javascript/durian.js-fastify location that demonstrates a NestJS backend using the Fastify adapter. The entry point (src/main.ts) initializes the NestJS application with a FastifyAdapter and listens on port 3000. The application includes a basic controller (src/app.controller.ts) with endpoints for a root greeting, retrieving a user by ID, and posting a new user. Configuration files for the Nest CLI, TypeScript build, and framework metadata (config.yaml) are also included to support the Bun engine.

javascript/durian.js-fastify · high confidence

A new benchmark application has been added to the Kotlin Hexagon Netty Epoll module. This standalone server uses the Netty Epoll transport to serve HTTP endpoints (including a user resource with POST and GET operations) on port 3000, allowing performance testing of the epoll-based network adapter.

go/fasthttp, kotlin/hexagon-netty-epoll · high confidence

A new Netty-based HTTP server adapter has been added to the Hexagon framework, providing an alternative to the existing Jetty implementation. This change introduces the \NettyServerAdapter\ class, which allows users to configure specific Netty behaviors such as executor thread counts, keep-alive handling, HTTP aggregation, chunked transfer, and WebSocket support. A benchmark example is included to demonstrate how to initialize and serve requests using this new adapter.

kotlin/hexagon-netty · high confidence

Introduces a new Next.js benchmark setup (version 16.3) that includes a custom server entry point, API routes for user data, and a cluster manager to utilize available CPU cores for performance testing.

javascript/nextjs · high confidence

This change introduces the Nifra framework (version 2.14) with dedicated implementations for both Bun and Node.js environments. For Bun, the \javascript/nifra-bun\ directory provides an application entry point and a cluster manager that spawns worker processes based on hardware concurrency. For Node.js, the \javascript/nifra-node\ directory offers a similar application structure using the \@nifrajs/node\ adapter and leverages the native \node:cluster\ module to manage worker processes across available CPU cores. Both implementations expose identical HTTP routes for root, user lookup, and user creation, listening on port 3000.

javascript/nifra-bun, javascript/nifra-node · high confidence

Added a new benchmark entry for the Nim Basolato web framework. This includes the application source code (main.nim, controllers), configuration files (config.nims, config.yaml, .env), and validation message translations for English and Japanese, enabling the framework to be tested in the benchmark suite.

nim/basolato · high confidence

Introduces a new Nim-based Caprese server component that listens on port 3000 and exposes three routes: a root endpoint, a user lookup by ID, and a user creation endpoint. The server is configured to disable SSL, enable standard HTTP headers (Server, Date, Content-Type, Active), and uses internal connection preferences.

nim/caprese · high confidence

Introduces a new Nim-based web framework integration for HappyX. The configuration specifies version 4.7 of the HapticX/happyx library and defines build optimizations including speed optimization, thread support, and memory allocation settings. The server implementation exposes basic HTTP endpoints for root access, user retrieval by ID, and user creation, along with a standard 404 handler for unsupported methods.

nim/happyx · high confidence

Introduces a new Nim-based HTTP server scaffold using the Prologue framework (version 0.6). The implementation includes a configuration file specifying the framework source and build options (specifically the reference counting memory manager), a Nim configuration file enabling threading (--threads:on), and a server source file that defines a basic application with GET and POST routes for root, user identification, and user creation, running on port 3000.

nim/prologue · high confidence

Added a new Nim-based server implementation using the Scorper framework (version 1.2). The server listens on port 3000 and handles HTTP GET and POST requests, returning the path ID for GET requests to paths starting with '/id/' and an empty response for other endpoints. The configuration disables threading support via the --threads:off compiler flag.

crystal/runcobo, nim/scorper · high confidence

Introduces a new Nim-based web server implementation using the Whip framework (version 0.2). The configuration specifies the GitHub source (mattaylor/whip) and build options (refc memory manager). The server exposes three endpoints: a root path returning an empty string, a user path accepting an ID parameter, and a POST endpoint for user creation, all listening on port 3000.

nim/whip · high confidence

Introduces a new benchmark adapter for the hashi HTTP server framework, implemented in Nim. The adapter configures the build environment to clone and bootstrap the pre-release Nimony compiler (Nim 3) from a pinned commit, then builds the application using pnak for dependency resolution. The server implementation defines standard REST endpoints (GET /, GET /user/:id, POST /user) and runs on port 3000, utilizing hashi's passive handler model for efficient I/O handling.

nim/hashi · high confidence

This change introduces a new OCaml implementation using the Dream web framework (version 1.0.0\~alpha7). It includes the necessary build configuration (Dune, opam), a sample server application that listens on port 3000, and a Dockerfile to containerize the environment using OCaml 5.2.

ocaml · high confidence

Introduced a new sample application in the fsharp/oxpecker directory that demonstrates the Oxpecker web framework (version 1.2). The sample includes a Program.fs file setting up an ASP.NET Core host with Kestrel, routing, and logging, exposing GET endpoints for the root and user details by ID, as well as a POST endpoint for user creation.

fsharp/oxpecker, fsharp/websharper · high confidence

Introduces the PowPow event-driven library (v0.2) with a configuration file specifying build options and dependencies (libssl-dev, libssl3), alongside a sample HTTP server implementation in Nim that listens on port 3000 and handles basic routing for user endpoints.

nim/powpow · high confidence

This change introduces new R-based web framework implementations for the benchmark suite, specifically adding support for Ambiorix (v2.2), httpuv (v1.6), Plumber (v1.3), RestRserve (v0.4), and Rserve (v1.8). Each framework is provided with its own Dockerfile (based on r-base:4.6.1), configuration, and application code to handle standard HTTP routes. The entry also includes a default R engine configuration that allows running generic R scripts via \source("app.R")\.

r · high confidence

This change introduces the Java RESTHeart benchmark service, including configuration files (config.yaml, .gitignore) and core service classes (RootService, UserService). The RootService handles the root path with a simple 200 response, while the UserService manages user-related requests, extracting user IDs from the URI path and returning them for GET requests. Both services are configured to bypass interceptors for performance and disable CORS headers.

java/restheart · high confidence

Introduces a new Java benchmark using the Rapidoid framework (version 5.5). The implementation configures the application to listen on port 3000 and defines three endpoints: a root handler returning plain text, a user lookup endpoint accepting an ID parameter, and a POST endpoint for user creation. Configuration includes setting a maximum HTTP pipeline of 128, disabling connection headers, and specifying the build and execution commands for the benchmark JAR.

(repo-wide) · high confidence

Added a new Restana-based JavaScript sample application that includes both CommonJS (app.js) and ES Module (app.mjs) entry points, along with a cluster implementation (cluster.mjs) that handles graceful shutdown via SIGINT and SIGTERM signals. The sample exposes basic REST endpoints and is configured for Restana version 6.1.

javascript/restana · high confidence

A new Rust project using the Rocket framework has been added to the repository. It provides a basic web server implementation with routes for an index page, retrieving a user by ID, and posting user data, configured to listen on port 3000.

rust/rocket · high confidence

Added new example applications for the Rust Iron and Nickel web frameworks. The Iron example implements a basic HTTP server with routes for an index page, user lookup by ID, and user registration, listening on port 3000. The Nickel example provides a similar structure using Nickel's middleware macros for route handling, also listening on port 3000.

rust/iron · high confidence

This change introduces a new Sails.js (v1.5) application template. It includes a cluster-aware entry point (\cluster.mjs\) that spawns worker processes using \node:cluster\ to handle production load, alongside a standard \app.mjs\ for development. The template configures a minimal API with home and user endpoints, disables the session hook by default via \.sailsrc\, and sets the production port to 3000 with permissive socket origins.

javascript/sails · high confidence

Introduces a new Rust-based HTTP server example using the Salvo framework. The application listens on port 3000 and exposes two endpoints: a root handler returning an OK status and a user handler that retrieves a user ID from the request path parameters. The implementation utilizes Salvo's routing and handler macros, running on a Tokio async runtime.

_nim/rosencrantz, rust/may\minihttp, rust/salvo · high confidence

Added a new Saturn-based web application example in the fsharp/saturn directory, featuring a basic router with GET and POST endpoints and a 404 handler, configured to use Saturn version 0.14.

fsharp/saturn · high confidence

The Scala environment now defaults to version 3.9 and includes new starter templates for several web frameworks: Cask (0.11), Finatra, http4s (0.23), Pekko HTTP (1.7), Play (3.0), and ZIO HTTP (3.11). Each template provides the necessary configuration files, build plugins, and sample route definitions to quickly scaffold an application using the respective framework.

scala · high confidence

New example applications have been added for the Sifrr and Turbo-Polka frameworks. The Sifrr examples (app.js, app.mjs, cluster.mjs) demonstrate basic HTTP routing and cluster management with graceful shutdown handling for SIGINT and SIGTERM signals. The Turbo-Polka examples (app.js, app.mjs) show integration of the Polka router with the turbo-http server. Both sets include configuration files specifying their respective engine dependencies.

javascript/sifrr · high confidence

A new C\# sample application using the Simplify.Web framework has been added. It includes a minimal web server setup in Program.cs that configures Kestrel and enables Simplify.Web middleware, along with controller classes for home, user, and user ID endpoints. The project is configured for .NET and targets Simplify.Web version 5.7.

csharp/simplify.web · high confidence

A new Spring Boot-based benchmark application has been added to the Java/Spring location, featuring REST endpoints for root, user ID retrieval, and user creation. The application is configured to run on port 3000 with error whitelabeling disabled and root logging set to ERROR. Notably, virtual thread support is enabled via the application properties, aligning with the project's move toward modern concurrency models.

java/spring · high confidence

Introduces a new Struts 2 (version 7.0) benchmark application that runs on Jetty 12.1.x with Jakarta EE 10 support. The implementation embeds Jetty to serve the Struts web application, configuring the StrutsPrepareAndExecuteFilter via web.xml (version 6.0) and defining RESTful routing in struts.xml. The application is packaged as a standalone JAR containing unpacked dependencies, executable via a main class that starts the embedded server on a configurable port.

java/struts2 · high confidence

This change introduces new Swift server implementations for the TechEmpower Framework Benchmarks, adding support for six distinct frameworks: Vapor (v4.121), Hummingbird (v2.25), Kitura (v3.0), Swifter (v1.5), Garuda (v1.0), and FlyingFox (v0.23). Each framework includes its own source code, configuration, and Dockerfile, enabling users to benchmark Swift applications built with these specific libraries. The implementations cover standard routes for GET /, GET /user/:id, and POST /user, with specific configurations for environment variables and build settings tailored to each framework's requirements.

swift · high confidence

Added new example applications in the rust/trillium-smol and rust/trillium-tokio directories that demonstrate how to run a Trillium web server using the smol and tokio async runtimes respectively. These examples configure the server to listen on 0.0.0.0:3000 and expose basic routing endpoints including a root path, a user detail path with an ID parameter, and a user creation endpoint.

rust/trillium-smol, rust/trillium-tokio · high confidence

This change introduces five new server implementations for the V programming language, providing users with a choice of HTTP frameworks for benchmarking and deployment. The \fasthttp\ and \pico\ directories add lightweight, low-level HTTP servers using the \fasthttp\ and \picoev\/\picohttpparser\ libraries respectively. The \vanilla\_epoll\ and \vanilla\_io\_uring\ directories provide raw V server implementations utilizing Linux \epoll\ and \io\_uring\ for high-performance I/O multiplexing, relying on the \vanilla\ module. Finally, the \veb\ directory adds a controller-based web framework using the \new\_veb\ library. All implementations follow the standard benchmarking pattern (GET /, GET /user/:id, POST /user) and are configured with specific build flags and dependencies in their respective \config.yaml\ files.

v · high confidence

Introduces a new Vert.x benchmark application (version 5.1) that serves as a high-performance HTTP server. The application listens on port 3000 and handles GET and POST requests, returning specific responses for root and user paths while rejecting invalid methods or paths with a 500 error. The deployment configuration specifies building via Maven and running the resulting JAR with an instance count based on the number of available processors.

java/vertx · high confidence

Introduces a new Java benchmark using Vert.x 5.1 that serves HTTP endpoints for root, user creation, and user retrieval on port 3000, configured to run as a single JAR executable scaled by the number of available CPU cores.

java/vertx4web · high confidence

Introduces a new Vixeny framework implementation for the Bun runtime. The application serves HTTP requests using Vixeny's routing capabilities, exposing endpoints for the root path, user retrieval by ID, and user creation via POST. It is configured to run as a multi-process cluster, spawning one worker per available CPU core and handling graceful shutdown signals (SIGINT, SIGTERM) to terminate all workers cleanly.

(repo-wide) · high confidence

New benchmark entries have been added for the Zig language, supporting the httpz and zzz frameworks. The httpz implementation uses the Karl Seguin http.zig library (commit 52eb187) and configures a server on port 3000 with handlers for root, user creation, and user lookup. The zzz implementation uses the tardy-org/zzz framework (version 0.3.2). Both entries require Zig version 0.16.0 and include Dockerfiles and build configurations to compile and run the respective server binaries.

zig · high confidence

Introduces a base \Benchmark::Action\ class that inherits from \Hanami::Action\ and defines the initial action handlers for the benchmark application, specifically \Benchmark::Actions::Index::Empty\ which returns an empty body and \Benchmark::Actions::User::Get\ which returns a user ID from request parameters.

ruby/hanami · high confidence

The Reinhardt web framework now includes a pre-configured 'benchmark' application, providing a ready-to-use RESTful API structure for performance testing. This scaffolding registers the app within the server's application registry and configures URL routing for three endpoints: a root index, a user detail view accepting an ID path parameter, and a user creation endpoint. The change also introduces a project management CLI (\manage.rs\) for executing commands and a settings module that supports environment-specific configuration via TOML files and environment variables, ensuring the benchmark app is wired into the server's startup sequence.

rust/reinhardt-web, rust/reinhardt-web/src/apps/benchmark · high confidence

Added a new Go example demonstrating the bunrouter HTTP router, including a configuration file and a main application that sets up basic GET and POST routes.

go/bunrouter · high confidence

A new application.conf file has been added to the kotlin/ktor/resources directory, defining the default deployment settings for the Ktor server. This configuration sets the default server port to 3000, allows overriding the port via the PORT environment variable, enables shared work groups, and specifies the main application module to load.

kotlin/ktor/resources · high confidence

Added new example applications for the iotjs-express and muneem frameworks, providing both CommonJS (app.js) and ES Module (app.mjs) implementations. These examples demonstrate basic HTTP routing (GET, POST) and include cluster management scripts (cluster.mjs) that handle graceful shutdown via SIGINT and SIGTERM signals.

javascript/iotjs-express, javascript/muneem · high confidence

Introduces a new Go example demonstrating the integration of the gorouter v4.4 library with the fasthttp engine. The provided main.go and config.yaml files show how to initialize a FastHTTP router, define routes (GET /, GET /user/{id}, POST /user), and start the server on port 3000, enabling users to leverage the high-performance fasthttp engine with the gorouter routing library.

go/gorouter-fasthttp · high confidence

The Spider-Gazelle benchmark application now includes a basic controller hierarchy. An abstract \Application\ controller has been added to serve as the base class for controllers, replacing the previous \ApiHelper\ module. Two concrete controllers, \User\ and \Welcome\, have been introduced to handle basic HTTP routes, providing a minimal endpoint structure for the benchmark.

crystal/spider-gazelle/src/controllers · high confidence

A new benchmark entry for the low-http-server framework (v4.2) has been added, utilizing the uWebsockets engine. The provided examples demonstrate both CommonJS and ES Module setups using the 0http router, and include a cluster configuration that spawns workers based on available CPU cores with graceful handling of SIGINT and SIGTERM signals.

javascript/low-http-server · high confidence

A new application entry point has been added in the \rust/hyper\ directory, implementing an HTTP server using the Hyper library. This service listens on port 3000 and handles GET requests for the root path and POST requests to \/user\ by returning an empty body, while GET requests to paths starting with \/user/\ return the remaining path segment as the response body. All other requests receive a 404 Not Found response.

rust/hyper · high confidence

Added a new example demonstrating the nhttp framework (version 2.0) for Deno. The entry includes the application code using the @nhttp/nhttp library to define basic HTTP routes and the necessary configuration files (deno.json and config.yaml) to set up the environment.

javascript/nhttp · high confidence

Introduces the routejs framework, providing a basic HTTP server setup with routing capabilities and multi-process cluster management. The application module defines standard GET, POST, and 404 routes using the @routejs/router library, while the cluster module enables primary-worker architecture that forks processes based on available CPU cores and handles graceful shutdown via SIGINT/SIGTERM signals.

javascript/routejs · high confidence

This change introduces a new Go application scaffold using the Mars web framework (v1.1). It includes a configuration file defining the framework source and bootstrap steps, a main entry point that configures the HTTP server on port 3000 with CSRF disabled, and a route configuration file mapping GET and POST endpoints for user resources.

go/mars · high confidence

Added support for the tinyhttp framework, including example application files (app.js, app.mjs) that demonstrate basic routing and a cluster configuration (cluster.mjs) that manages worker processes and handles SIGINT/SIGTERM signals for graceful shutdown. The configuration file sets the framework version to 3.0.

javascript/tinyhttp · high confidence

Added a new framework integration for uWebSockets.js (version 20.71). This includes a configuration file defining the framework and its engine, a cluster management script for multi-process scaling, and an application entry point that sets up a basic HTTP server on port 3000 with GET and POST routes. The implementation uses a CommonJS require wrapper to bypass a known ESM issue in the specific library version.

javascript/uwebsockets · high confidence

A new Scala application using the zio-http library has been added, providing a basic HTTP server example that serves routes for getting user details, a root endpoint, and creating users on port 3000.

scala/zio-http · high confidence

Introduces a new HTTP benchmark server implementation in the zzz module, providing a concrete entry point for performance testing. The server listens on port 3000 and exposes three routes: a root handler returning an empty HTML response, a parameterized route at /user/%s that echoes the captured segment, and a POST route at /user. It utilizes the zzz.tardy runtime with epoll for asynchronous I/O and configures the HTTP server with specific stack and buffer sizes to support the benchmark workload.

zig/zzz · high confidence

The cpp/oatpp directory now contains a complete starter project for the oatpp web framework (version 1.3). It includes a CMake build configuration that links against oatpp 1.3.0, a Docker ignore file, and a sample application structure. The application sets up an HTTP server on port 3000 using oatpp's dependency injection components and defines a basic API controller with endpoints for a root path, user creation, and user retrieval.

cpp/oatpp · high confidence

Added three new D language CGI server examples (hybrid, processes, and threads) that demonstrate different concurrency models provided by the arsd-official:cgi library (version 12). Each example configures a RequestServer on port 3000 and includes a handler that responds to POST requests and serves path info for /user routes.

_d/cgi\_hybrid, d/cgi\_processes, d/cgi\threads · high confidence

A new Rust application using the Warp framework has been added to the repository. This example server listens on port 3000 and exposes three endpoints: a root index, a user lookup by ID (GET /user/:id), and a user post creation endpoint (POST /user).

rust/warp · high confidence

The javascript/totaljs location now includes a new application structure based on Total.js v5. The entry point (app.cjs) requires the 'total5' module and defines basic GET and POST routes for the root and user endpoints, running on port 3000. A cluster.cjs file has been added to enable multi-process scaling by forking workers based on available CPU cores, handling graceful shutdowns via SIGINT/SIGTERM, and dynamically loading the app module. Configuration is managed via config.yaml, specifying the Node.js command to run app.cjs and setting the environment variable NODE\_APP.

javascript/totaljs · high confidence

Adds a new AdonisJS 7.0 application template (javascript/adonisjs-slim) that provides a minimal, production-ready structure. The template includes configuration for TypeScript execution via ts-exec, HTTP server entry points with graceful shutdown handling for SIGTERM/SIGINT, and a multi-process cluster launcher for scaling across available CPU cores. It also sets up core framework services including environment validation, container bindings, body parsing, encryption (AES-256-GCM), hashing (scrypt), and logging, along with basic HTTP routes for health checks and user management.

javascript/adonisjs-slim · high confidence

The HLEB2 framework has been introduced, providing new application bootstrap structures for the base framework, RoadRunner, and Swoole integrations. This includes the addition of container interfaces and factories that extend the core HLEB container system, enabling dependency injection and service management within these new runtime environments.

php/hleb2, php/hleb2-roadrunner, php/hleb2-swoole · high confidence

The Amber application in the crystal/amber/config directory is now initialized with a standard configuration file (application.cr) and a basic route definition (routes.cr). The configuration sets the server to listen on 0.0.0.0, enables port reuse, and allows the port to be overridden via the PORT environment variable. The routing layer defines a web pipeline and maps three basic endpoints: a root index, a user lookup by ID, and a user creation endpoint, all handled by ApplicationController.

crystal/amber/config · high confidence

This change introduces a new JavaScript/TypeScript application scaffold using the ChubbyTS framework. It includes an entry point (app.ts) that configures HTTP routing for index, user view, and user creation endpoints, wired to an undici-based server. Additionally, a cluster manager (cluster.mjs) is added to spawn worker processes across available CPU cores and handle graceful shutdowns via SIGINT/SIGTERM signals. Configuration files for TypeScript compilation (tsconfig.json) and environment setup (config.yaml) are also included to support the build and runtime environment.

javascript/chubbyts · high confidence

The php/fomo directory now contains the initial implementation of the Fomo application, introducing a new BenchmarkController for performance testing endpoints (such as retrieving or posting user data) and a custom Exception Handler that returns standardized JSON responses for 404, 405, and 500 errors.

php/fomo · high confidence

Added a new Go-based backend service using the Goyave framework (v5.12). The service includes a configuration file specifying the server listens on port 3000, and a main application entry point that registers basic HTTP routes for retrieving and creating user resources.

go/goyave · high confidence

Added a new Jester-based server entry that configures the framework version 0.6, sets the build options to use the reference counting memory manager, and enables threading via the \--threads:on\ compiler flag. The server listens on port 3000 and exposes routes for retrieving a user by ID and creating a new user.

nim/jester · high confidence

This change introduces the foundational structure for a new PHP Laravel application. It adds core framework components including the HTTP and Console kernels for request handling and scheduled tasks, a base controller class, and specific controllers for managing applications and users. Additionally, it includes the exception handler for error management and the route service provider to configure web routes, establishing the basic routing and request lifecycle for the service.

php/laravel · high confidence

This change introduces the initial configuration and dependency setup for the Lucky web framework within the benchmarking suite. It adds a \config.yaml\ declaring the framework version as 1.5, a \shard.yml\ pinning the \lucky\ dependency to version \~\> 1.5.0, and a \config/setup.cr\ file that configures the application for production use. Specifically, the setup disables debug output, sets a fixed session key, and configures the server to listen on all interfaces (0.0.0.0) on port 3000 or an environment-defined PORT.

crystal/lucky · high confidence

This change introduces the default resource files for the Luminus Clojure web framework template. It adds the HTML templates (home, about, error) using the Selmer templating engine, the Markdown documentation for the welcome page, and the CSS stylesheets including Material Icons support. These files provide the baseline UI and routing structure for new Luminus applications.

clojure/luminus/resources · high confidence

Adds a new D-based HTTP server using the Serverino framework (version 0.8). The service listens on port 3000, configures 1 worker with a backlog of 16, and exposes endpoints for a root health check, user creation, and user retrieval.

d/serverino · high confidence

The Symfony application is introduced with a new Kernel class and an ApplicationController. The Kernel sets up the standard Symfony directory structure for importing configuration packages, services, and routes based on the environment. The ApplicationController provides basic HTTP endpoints for health checks (ping), retrieving user details by ID, and creating new users.

php/symfony · high confidence

This change introduces the http4k framework to the Kotlin ecosystem, including a new configuration file specifying version 6.59, a .gitignore for build artifacts, and a benchmark server implementation using the Undertow engine to demonstrate basic routing and request handling capabilities.

kotlin/http4k · high confidence

Added a new Gearbox framework implementation for Go, configured to use version 1.2 of the gogearbox/gearbox library with the fasthttp engine. The entry point demonstrates a basic HTTP server setup on port 3000 with preforking explicitly disabled, exposing endpoints for root, user retrieval by ID, and user creation.

go/gearbox · high confidence

The repository is initialized with essential configuration files to standardize development and enable continuous integration. This includes a \.editorconfig\ for consistent code formatting across languages (Ruby, JavaScript, YAML, Dockerfiles), a \.rubocop.yml\ for Ruby linting, and a \.deepsource.toml\ to enable static analysis for Python, Ruby, and JavaScript. A \Rakefile\ is added to orchestrate build tasks, supported by a \config.yaml\ that defines cloud provider (Docker, DigitalOcean) and build metadata templates. Additionally, a \data.json\ file is introduced to store benchmark metrics, and a \CODE\_OF\_CONDUCT.md\ establishes community guidelines for contributors.

(repo-wide) · high confidence

This change introduces a new containerized environment for the Crystal Athena web framework, specifically configured for benchmarking. It includes a minimal server implementation (\src/server.cr\) that defines basic HTTP routes (GET/POST for root and user endpoints) and configures the application to run with reusable ports and a fiber context resized to the number of CPU cores. The setup relies on Athena framework version 0.21.0 and specifies necessary system dependencies like \libmagic\, \liblzma\, and \libbz2\ for build and runtime, with logging disabled to optimize performance metrics.

crystal/athena · high confidence

This change introduces a new Gleam project template in the \gleam/mist\ directory that scaffolds a basic HTTP server using the Mist framework (v6). The generated code includes a \server.gleam\ entry point that binds to port 3000 and routes requests to handle index pages and user-specific endpoints, alongside standard project configuration files like \gleam.toml\ and \manifest.toml\ to manage dependencies such as \gleam\_http\ and \gleam\_stdlib\.

gleam/mist · high confidence

This change introduces the new Yume server application, providing a basic HTTP service with routes for listing users, retrieving a user by ID, and creating users. The server is configured to run on Node.js 24 using the uWebSockets engine and includes a cluster manager that spawns worker processes based on available CPU cores. It also implements graceful shutdown handling for SIGINT and SIGTERM signals to ensure clean termination of the cluster.

javascript/yume-server · high confidence

This change introduces the foundational file structure for the Blaze Node application, including the main entry points (app.js, app.mjs), a cluster manager for multi-process handling with graceful shutdown support, and service definitions for core and user functionalities. The application is configured to use the @busy-hour/blaze framework version 4.4 and includes a .gitignore file for Node.js artifacts.

javascript/blaze-node · high confidence

Adds a new Rust-based web service using the Viz framework, featuring a basic HTTP server on port 3000 with routes for listing users, creating users, and showing user details by ID.

rust/viz · high confidence

This change introduces the core application files for Spider-Gazelle, a web server built with the Crystal language. The \app.cr\ file provides the entry point, allowing users to configure the server host, port, and worker thread count via command-line arguments or environment variables, and includes utilities to list routes or display the version. The \config.cr\ file sets up the ActionController framework, configures session cookie settings (with defaults for key and secret), and disables logging by default. This represents the foundational structure for the application's server-side logic.

crystal/orion, crystal/spider-gazelle/src · high confidence

Introduces the Supranim framework for Nim, providing a structured web application setup. The release includes a default server configuration (server.nim) that initializes the HTTP router and loads settings from config.yaml, which specifies build options like atomic memory management and dependencies such as libssl. It defines a basic routing layer (routes.nim) mapping endpoints like GET / and POST /user to controller implementations (controller/pages.nim, controller/errors.nim) that handle responses and user data. A base middleware component (service/middleware/base.nim) is added to handle URI normalization, specifically redirecting trailing slashes. The project structure also includes configuration files (config.nims, config.yaml) and placeholder directories for models, database migrations, and event listeners, establishing the foundational architecture for the application.

go/breeze, javascript/vixeny-deno, nim/supranim · high confidence

The go/web package is introduced as a new web framework, providing a server implementation with routing capabilities. The included example demonstrates defining GET and POST routes, accessing URL parameters, and running the server on port 3000.

go/web · high confidence

The violetear Go package is introduced as a new HTTP routing library. The provided example application demonstrates its usage by setting up a server on port 3000 with specific route handlers (including regex-constrained paths like /user/:id) and configuring standard server timeouts.

go/violetear · high confidence

This change introduces the spliffy framework within the www directory, adding new runtime JavaScript files to define basic HTTP route handlers. Specifically, it establishes a root GET endpoint, a user resource endpoint that extracts an ID from the URL, and a user creation POST endpoint, laying the groundwork for the application's web interface routing.

javascript/spliffy/www · high confidence

The repository now includes a new Minimal API sample for ASP.NET Core running on .NET 10. This example demonstrates a basic web application setup, including Kestrel configuration to hide the server header, logging initialization, and simple HTTP endpoints for retrieving and creating user resources.

csharp/aspnet-minimal-api · high confidence

Added a new Atreugo-based engine implementation for the Go runtime, featuring a sample server configuration (config.yaml) specifying version 11.13 and the fasthttp engine, along with a main.go entry point that demonstrates basic routing for GET and POST endpoints on port 3000.

go/atreugo · high confidence

Added initial support for the Coast web framework, including a configuration file that defines the build process (using \clj\ and \uberdeps\) and runtime command, a \deps.edn\ specifying Coast 0.1.0-SNAPSHOT and Clojure 1.12.6, and a sample server implementation demonstrating basic routing and request handling.

(repo-wide) · high confidence

Adds a new Crystal-based server component (\crystal/toro\) that serves as a basic HTTP API scaffold. It depends on the \soveran/toro\ library (version \~\> 0.5.0) and configures a router with placeholder routes for user management (creating users and retrieving user details by ID). The server is configured to listen on port 3000 and utilizes a fiber context execution pool sized to the number of CPU cores.

crystal/toro · high confidence

Adds a new Cubex-based application structure under php/cubex, featuring a base Application class that defines routes for user and home endpoints and utilizes the Packaged HTTP response class. A corresponding Workerman adapter is provided in php/cubex-workerman to enable running the application via the Workerman server, extending the base controller to handle routing and request processing.

php/cubex · high confidence

The csharp/effinitive-framework location now includes an initial implementation of the Effinitive framework (version 1.2). This adds a new Program.cs that configures the application to run on port 3000 and defines three endpoints: a root GET endpoint at '/', a GET endpoint at '/user/{id}' that returns the user ID from the route, and a POST endpoint at '/user'. The configuration file specifies the framework source as HBartosch/Effinitive.

csharp/effinitive-framework · high confidence

Added a new Go-based API router component that provides a framework for defining HTTP routes. The implementation includes a configuration file specifying the framework details and a main entry point that demonstrates routing for GET requests on the root and user ID paths, as well as a POST request for user creation, serving on port 3000.

go/apirouter · high confidence

Added a new Go-based sample application in the \go/webgo\ directory that demonstrates the webgo framework. The application configures a router to serve HTTP requests on port 3000, implementing endpoints for the root path and user ID retrieval via URI parameters.

go/webgo · high confidence

Added a new GoFrame application example that initializes an HTTP server on port 3000 using GoFrame v2.10. The server implements a custom handler that returns a 200 OK for the root and /user paths, echoes the user ID for /user/{id} paths, and returns a 404 Not Found for all other routes.

go/goframe · high confidence

Added a new integration for the Julia Oxygen framework, including a server script that starts an HTTP service on port 3000 with basic routing for root, user ID retrieval, and user creation endpoints. The configuration specifies Oxygen version 1.11 and includes dependency management via Project.toml and deps.jl to ensure the correct registry and packages are available.

julia/oxygen · high confidence

This change adds a new MoroJS-based application entry point (app.mjs) and configuration that explicitly selects the uWebSockets.js engine, replacing the deprecated useUWebSockets option. It configures request logging and tracking to be disabled, sets the error boundary to disabled, and optimizes worker clustering by using availableParallelism() to respect container CPU affinity masks rather than counting all host CPUs. The application exposes basic GET and POST endpoints for user resources and is supported by a cluster entry point that leverages MoroJS's internal clustering mechanism.

javascript/morojs-uws · high confidence

This change adds a new NestJS engine variant using the Fastify adapter (javascript/nestjs-fastify), distinct from the existing Express-based engine. The Fastify implementation configures NestJS to use the FastifyAdapter, listens on 0.0.0.0, and includes a cluster.mjs script to fork worker processes across available CPUs with graceful shutdown handling for SIGINT and SIGTERM. It also adds a TypeScript declaration shim for worker\_threads compatibility and updates the build configuration to support the new adapter.

javascript/nestjs-fastify · high confidence

Adds the initial PHP implementation of the Hamlet application, featuring an HTTP router that maps GET requests for the root path and specific user IDs to plain-text responses, and POST requests to the /user endpoint. The application includes resource classes for the application info, user creation, and user ID retrieval, along with an in-memory cache implementation.

php/hamlet · high confidence

A new JavaScript-based web framework named PXE is introduced, providing both CommonJS (app.js) and ES Module (app.mjs) entry points that utilize the @pxe/server package. The framework includes a basic routing example that extracts user IDs from URLs and serves them as responses. Additionally, a cluster management module (cluster.mjs) is added to enable multi-process scaling by forking workers based on available CPU cores, with proper handling of SIGINT and SIGTERM signals for graceful shutdown.

javascript/pxe · high confidence

A new Rust HTTP server implementation has been added to the khttp module, providing endpoints for the root path, user creation, and user retrieval. The server listens on port 3000 and utilizes the epoll backend for handling connections.

rust/khttp · high confidence

Adds a new JavaScript framework entry for Ultimate Express (v2.2), configured to use uWebSockets engines. The included application example demonstrates basic routing and server setup, while the cluster configuration enables multi-process handling with graceful shutdown on SIGINT and SIGTERM signals.

javascript/ultimate-express · high confidence

Added a new benchmark application using the fulmine.js framework (version 5.21) which leverages uWebSockets.js for high-performance HTTP handling. The application configures an Express-compatible API with specific optimizations: it disables ETags and connection headers to reduce overhead, enables declarative request values to allow compiled responses for static routes, and uses direct response ending to avoid unnecessary content-type headers. The app exposes endpoints for root, user ID retrieval, and user creation, running on port 3000 with auto-clustered workers.

javascript/fulmine.js · high confidence

A new Go-based HTTP routing framework named 'goroute' is introduced, providing a standard library-compatible routing interface. The implementation includes a configuration file defining the framework's identity and version, alongside a main entry point that demonstrates core capabilities such as handling static paths, parameterized routes (e.g., /user/:id), and POST endpoints, all served via a standard HTTP listener on port 3000.

go/goroute · high confidence

Added a new Go engine based on the gramework framework (v1.8) using Go 1.21. This engine provides a lightweight HTTP server configuration with a production environment setting and listens on port 3000, exposing basic GET and POST routes for user data handling.

go/gramework · high confidence

A new uWebSockets.js engine is now available for the RouteJS framework. This addition includes the core application setup using the uWebSockets.js library, a cluster configuration script to leverage multiple CPU cores, and a configuration file declaring the new engine alongside the existing framework version 3.0.

javascript/routejs-uwebsocket · high confidence

Added the main entry point for the Crystal Amber framework (\src/amber.cr\) which initializes the application configuration, resizes the default Fiber execution context to match the number of CPU cores, and starts the Amber server. A corresponding benchmark entry point (\src/benchmark\_amber.cr\) was also added to require the main server module.

crystal/amber/src · high confidence

A new Go-based HTTP service has been added using the guregu/kami framework (version 2.2). This service exposes three endpoints: a root index, a user retrieval endpoint at /user/:id, and a user creation endpoint at /user. The application is configured to listen on port 3000.

go/kami · high confidence

The Lucky Framework for Crystal has been added to the project. This change introduces the core server initialization logic, configuring the HTTP server to listen on the host and port defined in the application settings, utilizing the route handler, and adjusting the fiber execution context to match the system's CPU count.

crystal/lucky/src · high confidence

This change introduces the Spliffy framework (version 1.4) for JavaScript applications. It provides a standard entry point (app.js/app.mjs) that initializes the server on port 3000 using the @srfnstack/spliffy package, configuring routes from a 'www' directory. Additionally, a cluster.mjs module is added to enable multi-process scaling by forking workers based on available CPU cores, with proper handling for SIGINT and SIGTERM signals to ensure graceful shutdowns.

javascript/rayo, javascript/spliffy · high confidence

A new Vibe.d-based HTTP server example has been added to the repository, providing a minimal implementation for handling GET and POST requests on /user endpoints and a root path. The project is configured via dub.json to depend on vibe-http-light and vibe-stream-light (with TLS disabled), and utilizes manual memory management and high event priority settings. The server listens on port 3000, binds to all interfaces, and employs worker threads for request handling.

_d/vibed\light · high confidence

A new JavaScript framework named Mesh has been added to the codebase, replacing the previous 'Fiber' implementation. This includes a basic application structure with HTTP routing (app.mjs), a cluster manager that handles multi-process forking and graceful shutdown via SIGINT/SIGTERM signals (cluster.mjs), and configuration for the uWebSockets engine (config.yaml).

javascript/mesh · high confidence

A new Rust-based HTTP server named 'Silent' has been added to the project. The implementation defines a basic route structure with an empty index endpoint and a user endpoint that accepts an ID parameter, binding to port 3000 on all interfaces.

rust/silent · high confidence

A new Express.js sample application has been added, featuring an ES module-based entry point (app.mjs) that listens on port 3000 and a cluster manager (cluster.mjs) that spawns worker processes based on available CPU cores. The application explicitly disables the X-Powered-By header and etag generation for security and performance, and includes proper handling for SIGINT and SIGTERM signals to ensure graceful shutdown of the cluster. The entry also includes a .gitignore file for Node.js artifacts and a configuration file specifying the framework version.

javascript/express · high confidence

Added new Rust-based web server integrations for ZenoLang using the Actix-web and Axum frameworks. These entries allow users to run ZenoLang applications as HTTP servers, supporting GET and POST routes defined in \app.zl\. The implementation includes a fallback mechanism to embed \app.zl\ at compile time via \include\_str!\ for containerized environments, ensuring the application runs correctly even when the file is not present at runtime.

rust/zeno-rs-actix, rust/zeno-rs-axum · high confidence

The Python benchmark environment has been upgraded to Python 3.14, introducing a significantly broader set of supported web frameworks and server configurations. This update adds implementations for Baize (split into ASGI and WSGI variants), Asgineer, FastPySGI (ASGI and WSGI), Heaven, Lihil, and MQ-Bridge-Py, while also updating existing frameworks such as Django to 6.1, FastAPI to 0.141, and Masonite to 5.4. The Dockerfile and configuration infrastructure have been standardized to support these additions, ensuring consistent execution across the expanded list of engines including Granian, Uvicorn, and Gunicorn.

python · high confidence

The JavaScript location now provides a unified configuration structure and dedicated Dockerfiles for supported runtimes. A new config.yaml defines the base Node.js version (26-slim) and specifies engine-specific settings for Node, Turbo, uWebSockets, Deno, HappyX, and Bun, including their respective bootstrap commands and entry points. Corresponding Dockerfiles (node.Dockerfile, bun.Dockerfile, deno.Dockerfile) and symlinks (turbo.Dockerfile, uwebsockets.Dockerfile) are introduced to build containers for these engines, alongside a .gitignore and .prettierrc to standardize development environment hygiene.

javascript · high confidence

The source files for the HTTP benchmark client (src/client.cr) and the route-based server implementation (src/server\_route\_cr.cr) have been deleted. This removes the ability to run the specific multi-threaded HTTP benchmark against the localhost:3000 server endpoints (/ and /user) and eliminates the server code that utilized the Route library for handling these specific routes.

src · high confidence

The server\_rails directory has been stripped of its default Rails application structure. This change removes all generated scaffolding, including the API controller and its tests, standard views and layouts, asset pipeline files (JavaScript, CSS, and images), and Action Cable channel stubs. Additionally, all default configuration files (such as routes, environment settings, initializers, and secrets) and utility scripts (bin/rails, bin/setup) have been deleted, leaving the directory empty of application code.

_server\rails · high confidence

The project has replaced its previous Rakefile-based automation with a modular set of tasks in the .tasks directory, introducing significant changes to how benchmarks are executed, measured, and reported. The new harness uses the zrk load generator in closed-loop mode to accurately measure sustained throughput, replacing the previous open-loop ramping method. It introduces three new measurement probes: a CPU saturation probe that validates whether the server was the bottleneck (previously ranking frameworks by load-generator limits), a fixed-rate latency pass that measures latency at a defined load to avoid coordinated-omission errors, and a memory sampler that tracks peak and average memory usage under load. The CI matrix logic has been rewritten to dynamically detect changed languages and frameworks, with specific exclusions for io\_uring-based frameworks on GitHub Actions runners. Results are now collected into a PostgreSQL database and exported as JSON and Markdown tables, providing more granular metrics including latency percentiles, error counts, and CPU saturation data.

.tasks · high confidence

The Elixir runtime is upgraded to version 1.20, and the configuration now includes support for the Bandit adapter alongside existing Cowboy and Plug options. New framework configurations are added for Phoenix with Bandit, Plug with Bandit, and standalone Cowboy/Cowboy Stream, allowing users to select these specific web server adapters for their applications.

elixir · high confidence

The Go Echo example has been updated to use framework version 5.3, as indicated by the new config.yaml. The main.go file demonstrates a basic HTTP server setup using the Echo v4 library (imported as github.com/labstack/echo/v4), implementing GET endpoints for the root and user details, a POST endpoint for user creation, and listening on port 3000.

go/echo · medium confidence

The Kemal benchmark entry has been moved to its own directory (crystal/kemal) and upgraded to use the kemal shard version \~\> 1.13.0. The application now runs in production mode with static file serving and logging disabled to reduce overhead, and the fiber execution context is resized to match the number of CPU cores for better parallelism.

crystal/kemal · high confidence

The application now uses a new set of Aspectran configuration files (app-description.xml, aspectran-config.apon, tow-server.xml, web-rules.xml) to define the embedded Undertow web server and its endpoints. The server listens on a configurable HTTP port (defaulting to 3000) and host (0.0.0.0), with the port value being dynamically resolved via a placeholder syntax. Three web endpoints are defined: GET /, GET /user/${id}, and POST /user. The configuration also includes settings for URL decoding (UTF-8) and trailing slash redirects.

java/aspectran/config · high confidence

The Ruby benchmark environment has been upgraded to Ruby 4.0, with the Rails and Rails-API implementations updated to version 8.1. This change includes a comprehensive configuration overhaul for Rails 8.0 defaults, such as replacing \cache\_classes\ with \enable\_reloading\, updating database storage paths to \storage/\, and adjusting middleware and environment settings for production and development. Additionally, new framework implementations have been added for Agoo (v2.15), Camping (v3.2), Cuba (v4.0), Hanami (v3.0), Hanami-API (v0.3), Rack::App (v11.0), Rage (v1.28), Roda (v3.108), Sinatra (v4.2), and Syro (v3.2), while Grape has been updated to v4.0.

ruby · high confidence

The Rust benchmark environment has been upgraded to use the Rust 1.98 compiler, as defined in the new \rust/config.yaml\. This update introduces several new web frameworks to the benchmark suite, including Argan, Hyperlane, and mq-bridge, alongside fresh implementations for existing frameworks like Graphul, Micro-web, and Summer-boot. Additionally, versions for established frameworks have been updated, such as Actix to 4.8, Axum to 0.8, Poem to 3.0, and Salvo to 0.96. The \rust/Dockerfile\ has been added to standardize the build process, ensuring all frameworks are compiled with Link-Time Optimization (LTO) and panic abortion for consistent performance metrics.

rust · high confidence

The http4s benchmark implementation now uses the Ember server as its underlying HTTP engine, replacing the previous default backend. This change updates the server startup logic to configure and run via EmberServerBuilder, which may affect performance characteristics and resource usage for the http4s benchmark entry.

scala/http4s · high confidence

The Giraffe sample applications in the fsharp/giraffe and fsharp/giraffe-endpoints directories have been updated to use Giraffe version 6.0. The fsharp/giraffe-endpoints sample now utilizes the new EndpointRouting feature, configuring routing via \UseRouting\ and \MapGiraffeEndpoints\, while the fsharp/giraffe sample continues to use the traditional \UseGiraffe\ middleware approach. Both samples are configured to run on the modern .NET Generic Host.

fsharp/giraffe · high confidence

The Suave web server example has been updated to use framework version 3.5, as indicated by the new configuration file. The application code in Program.fs has been refreshed to implement a basic HTTP server using the Suave router, featuring endpoints for retrieving a user by ID and creating a new user, listening on port 3000.

fsharp/suave · high confidence

Added RSpec test suite for helper utilities and HTTP routes; Initial test coverage for spider-gazelle Crystal framework; Removal of stubbed server test suite.

The Luminus project template has been updated to version 4.52, upgrading the default Clojure compiler from 1.11.x to 1.12.6 and setting the required Java version to 21. This release also updates core dependencies including Ring to 1.15.5, Reitit to 0.10.1, Jackson to 2.22.2, and Logback to 1.6.3. The template now generates a project structure with separate development, production, and test environment configurations, including specific logback settings and middleware wrappers for each profile.

clojure/luminus · high confidence

This release updates dependencies in 352 manifests across the project. The changes include version bumps for various web frameworks and libraries such as Laravel, Quarkus, Fastify, Go Fiber, and Rust Salvo, along with updates to build tools like Maven plugins and the Kotlin compiler plugin. These updates ensure that the project uses the latest stable versions of its dependencies.

(dependencies) · high confidence

The Go Fiber implementation has been upgraded from the v2 series to v3.5. This update changes the underlying dependency to github.com/gofiber/fiber/v3 and adjusts the application configuration to use v3-specific settings, such as enabling case-sensitive routing and strict routing by default, while disabling header normalizing and prefork.

go/fiber · high confidence

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

• CAI 27 → 36 (+8.7)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 70 → 50 (-20.2)
• Architecture 97 → 83 (-14.0)
• Maturity 22 → 52 (+29.4)
• Readiness 12 → 27 (+15.0)
• Security 45 → 29 (-15.5)
• Performance 83 (new)

• Change coupling: app.js ↔ app.js (javascript/express/app.js)
• Change coupling: app.js ↔ app.js (javascript/express/app.js)
• Change coupling: app.js ↔ app.js (javascript/express/app.js)
• Change coupling: app.js ↔ app.js (javascript/hapi/app.js)
• Change coupling: app.js ↔ app.js (javascript/hapi/app.js)
• Change coupling: app.js ↔ app.js (javascript/koa/app.js)
• Coverage not measured — test suite did not build
• Dimension evaluation failed
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• Medium CVE: GO-2025-3749 (go/breeze/go.mod)
• Medium CVE: GO-2025-3750 (go/breeze/go.mod)
• Medium CVE: GO-2025-3751 (go/breeze/go.mod)
• Medium CVE: GO-2025-3849 (go/breeze/go.mod)
• Medium CVE: GO-2025-3956 (go/breeze/go.mod)
• Medium CVE: GO-2025-4006 (go/breeze/go.mod)
• …and 39 more

• Change coupling: RootService.java ↔ UserService.java (java/restheart/src/main/java/org/restheart/RootService.java)
• CommentedOutCode (java/light-4j/src/main/resources/config/handler.yml)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (10 lines × 2) (php/basicphp/Basic.php)
• Duplicated block (11 lines × 2) (php/basicphp/Basic.php)
• Duplicated block (13 lines × 2) (php/basicphp/Basic.php)
• Duplicated block (22 lines × 2) (php/imi-swoole/ApiServer/Controller/IndexController.php)
• Duplicated block (26 lines × 2) (php/basicphp/Basic.php)
• Duplicated block (3–5 lines × 3) (php/mixphp-swoole/src/Vega.php)
• Duplicated block (6 lines × 2) (php/hamlet/src/Application/Resources/ApplicationResource.php)
• Duplicated block (7 lines × 2) (php/basicphp/Basic.php)
• Duplicated block (7 lines × 3) (php/basicphp/Basic.php)
• Duplicated block (8 lines × 2) (php/basicphp/Basic.php)
• Duplicated block (8–10 lines × 3) (php/basicphp/Basic.php)
• Further sole-owners (lower concentration)
• High IaC: WD-DOCKER-0009 (cpp/Dockerfile)
• High IaC: WD-DOCKER-0009 (v/Dockerfile)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 187 more

• 300 commits — 293 feature/other, 7 fixes

• (repo) — 143 commits
• (root) — 27 commits
• c/cwist — 13 commits
• .github/workflows — 4 commits
• crystal/spider-gazelle — 4 commits
• java/quarkus — 4 commits
• .tasks/ci.rake — 3 commits
• d/serverino — 3 commits
• go/goyave — 3 commits
• java/aspectran — 3 commits
• java/restheart — 3 commits
• javascript/fulmine — 3 commits
• javascript/fulmine.js — 3 commits
• javascript/uwebsockets — 3 commits
• nim/hashi — 3 commits
• php/laravel — 3 commits
• python/heaven — 3 commits
• python/veloce — 3 commits
• rust/mq-bridge — 3 commits
• clojure/luminus — 2 commits

• fix: Add fixed-rate latency measurement and reporting functionality
• fix: Fix cwist build: add missing vendored include paths
• fix: Merge pull request #9718 from nigrosimone/fix-config-website-leak
• fix: Merge pull request #9748 from gg582/fix-cwist-sqlite3-include
• fix: fix nim/powpow and nim/supranim
• fix: fix(app.cr): only implement one scaling mode
• fix: fix: recursive_merge kept the previous framework's config, so 230 frameworks published the wrong website
• change: Add -Icwist/lib to include path for cjson header resolution
• change: Add CPU cores usage metrics and update README for clarity
• change: Add CPU saturation measurement and reporting tasks
• change: Add Garuda (Swift)
• change: Add cwist (C)
• change: Add detailed measurement explanations for benchmark runs in README
• change: Add jet_server (Dart)
• change: Add nim/hashi
• change: Add peregrine, as a raw ASGI/WSGI server and under FastAPI and Django
• change: Added worker backlog
• change: Change worker count from 4 to 1
• change: Include morojs entry updates
• change: Merge branch 'develop' into master
• …and 280 more

• Unchanged — 3 HTTP endpoints

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

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