Open-source alternatives to Hertz

Kratos is a toolkit for building cloud-native microservices in Go. It provides a comprehensive suite of framework primitives, including a dedicated toolset for API-first development using Protobuf to generate server and client code for gRPC and HTTP. The project is distinguished by its pluggable service infrastructure, which allows for the swapping of configuration stores, service registries, and data encoding formats. It utilizes a composable middleware pipeline to inject cross-cutting concerns such as authentication, request validation, and circuit breaking into the service flow. The frame

This project is a comprehensive sample library and implementation guide for ASP.NET Core. It provides a collection of practical examples and projects that demonstrate how to build web applications, RESTful APIs, and high-performance services. The repository focuses on a variety of architectural patterns, including the development of Minimal APIs, contract-first gRPC services, and real-time communication using WebSockets and Server-Sent Events. It includes detailed implementations for user identity and security, such as token-based authentication and CSRF protection. The codebase covers a bro

FastMCP is a Python framework designed for building servers that expose functions, resources, and prompts to AI models using the Model Context Protocol. It simplifies the development process by automatically deriving tool metadata, input schemas, and documentation directly from Python function signatures and type hints. The framework provides a unified container for managing these components, allowing developers to build modular applications that integrate seamlessly with AI assistants. The project distinguishes itself through its support for interactive, server-defined user interface compone

Workerman is an event-driven asynchronous socket framework for PHP. It provides the core components necessary to build high-concurrency network servers, including an asynchronous TCP framework, a coroutine library for task management, and dedicated implementations for HTTP and WebSocket servers. The project enables the development of specialized network services using custom frame-based communication protocols. It supports both inbound concurrent server implementation and asynchronous outbound connectivity to remote services. The framework covers a broad range of network programming capabili

grpc-rust is a native gRPC framework for Rust designed for building high-performance remote procedure call clients and servers. It provides an asynchronous communication stack and a protocol buffers implementation for encoding, decoding, and generating type-safe code from service definitions. The project enables the implementation of unary and bi-directional data streaming over the HTTP/2 protocol. It includes specialized support for gRPC-Web integration, allowing browser-based clients to communicate with services through protocol translation. The infrastructure covers a broad range of distr

Polka is a minimalist Node.js web framework and HTTP routing engine. It provides a small-footprint server implementation designed for low overhead, mapping URL paths and HTTP methods to specific handler functions. The project utilizes a middleware-based architecture, processing requests through a sequence of functions to handle tasks such as logging, authorization, and data modification. It allows for the organization of these functions into global and path-filtered groups to control execution order. The framework covers core web capabilities including route parameter extraction, request URL

Revel is a full-stack web framework and toolkit for building applications with the Go language. It implements a model-view-controller architecture to separate business logic from user interface rendering, providing a comprehensive system for routing, parameter binding, and session management. The project distinguishes itself with a high-productivity development environment featuring automatic code compilation and hot-reloading, which refreshes the application state and templates upon file changes without requiring manual restarts. It also employs reflection-based parameter binding to automati

Lumen is a PHP micro-framework and REST API framework designed for building high-performance web applications and lightweight services. It provides a streamlined environment for developing independent, small-scale web services that handle specific business logic. The framework is focused on microservices development and the creation of stateless web endpoints. It provides a minimal architecture to reduce operational overhead when constructing high-performance backend services and rapid web API prototypes. The system incorporates request dispatching and filtering through middleware, utilizing

Kitura is a server-side web framework for building HTTP services and web applications using the Swift programming language. It functions as an HTTP server that handles incoming requests, routes traffic, and serves responses. The framework serves as a Codable REST API framework, enabling the encoding and decoding of native Swift data types for web service communication. It also provides a FastCGI web interface to connect Swift applications to external web servers for improved scalability. The system includes capabilities for secure web communication through SSL/TLS network encryption, server-

Crow is a minimalist C++ micro web framework designed for building fast web servers and REST APIs. It provides a lightweight toolkit for web development in C++, offering core routing and request handling capabilities. The framework includes a built-in JSON parser for converting strings into structured data and an HTML template engine for generating dynamic web pages on the server. It also functions as a WebSocket server library to enable bidirectional, real-time communication between servers and web clients. Additional capabilities include a middleware-based request pipeline for executing sh

Grape is a RESTful web service framework for Ruby designed for building structured APIs. It provides a declarative syntax for routing and parameter validation, allowing developers to map HTTP verbs to logic through a domain specific language. The framework is distinguished by its built-in support for service versioning, which can be managed via URL paths, custom headers, or request parameters. It also features a modular architecture that allows large services to be constructed by nesting smaller API definitions. The project covers comprehensive API lifecycle capabilities, including schema-dr

Swift NIO is a low-level, event-driven network framework for the Swift language. It serves as an asynchronous network protocol stack and I/O library designed to build high-performance network servers and clients that handle thousands of simultaneous connections. The framework functions as a high-concurrency network engine that dispatches events across multiple CPU cores. It enables the implementation of custom network protocols by processing raw bytes through a sequence of reusable data transformation handlers. The system provides capabilities for non-blocking I/O multiplexing, asynchronous

Martini is a web framework for the Go programming language that provides a toolkit for building web applications. It functions as a routing engine and an HTTP middleware pipeline to map network requests to specific handler functions. The framework is distinguished by its dependency injection system, which automatically resolves and provides requested service types as arguments to handler functions. This allows for the decoupling of business logic from infrastructure by matching requested types against a registry of available services. The project covers a broad range of web capabilities, inc

Koa is a lightweight web framework for Node.js designed for building HTTP applications and servers. It functions as an asynchronous middleware engine that processes network requests through a sequence of functions sharing a common context. The framework distinguishes itself by using an onion-model middleware stack and promise-based flow control. This architecture allows requests to flow downstream and responses to flow back upstream through the same chain, enabling non-blocking request cycles and a modular approach to handling network traffic. The system provides high-level capabilities for

tarpc is a remote procedure call framework for Rust that generates server traits and client stubs for network communication. It provides an asynchronous service interface that allows remote functions to be called as if they were local asynchronous tasks. The framework utilizes a serialized transport layer to move request and response data via TCP sockets, Unix domain sockets, or in-process channels. It includes a request lifecycle interceptor for injecting custom logic to handle authorization, throttling, and load balancing, as well as a distributed request telemetry system that attaches dead

gnet is a high-performance event-driven networking framework for Go, designed for building scalable TCP, UDP, and Unix socket servers. It functions as a non-blocking socket manager and multi-reactor network engine that handles thousands of simultaneous connections with low memory overhead. The framework distinguishes itself by using a multi-reactor architecture that distributes I/O across multiple event loops pinned to operating system threads to minimize context switching. It employs edge-triggered polling to reduce system call frequency and utilizes elastic ring-buffers to minimize allocati

grpc-spring is a framework for integrating gRPC servers and clients into Spring applications. It provides a suite of tools for managing the lifecycle of remote procedure call servers, automating client stub injection, and implementing request interception within a Java environment. The project enables high-performance remote procedure call communication through annotation-driven service registration and automatic configuration of client stubs. It includes a specialized interceptor library for modifying requests and responses, as well as a telemetry tool for exporting performance metrics and d

Warp is a Rust HTTP web framework designed for building high-performance web servers. It provides a system for managing request pipelines, implementing WebSocket servers for bidirectional communication, and serving static assets from the local filesystem. The framework is characterized by its use of type-safe request pipelines and routing. It utilizes a filter-based approach to extract and validate metadata from headers, query strings, and request bodies before they reach the application handler. Broad capability areas include HTTP API development, asynchronous task execution, and state-base

Kit is a microservices architectural framework and toolkit for Go. It provides a set of standardized primitives and abstractions for implementing service, endpoint, and transport layers in a decoupled manner. The framework focuses on system instrumentation through integrated distributed request tracing and a service instrumentation toolkit that utilizes counters and gauges to export performance data to external monitoring backends. It includes a structured logging library that records system events as key-value pairs to ensure compatibility with log aggregation tools. The project covers a br

Blog.Core is a production-ready backend boilerplate for building enterprise APIs and microservices using ASP.NET Core. It provides a foundational infrastructure for distributed systems, including tools for database-first scaffolding and the implementation of multi-tenant API frameworks. The project distinguishes itself through automated data layer generation, which produces entity models and repository layers directly from database schemas. It implements a centralized identity management system using standard identity server protocols to handle authentication and authorization across multiple

Yoga is a GraphQL server framework and runtime-agnostic HTTP handler used to build and deploy GraphQL APIs. It functions as a toolkit for managing schemas and resolvers, providing a spec-compliant environment for hosting APIs across diverse JavaScript runtimes, including Node.js, Deno, Bun, and serverless cloud environments. The project distinguishes itself through its ability to act as an Apollo Federation gateway, composing multiple subgraphs into a single unified supergraph. It also serves as a dedicated subscription server, delivering real-time data streaming via both WebSockets and Serve

gqlgen is a schema-first Go library designed to build type-safe GraphQL servers. It functions as a code generation engine that transforms declarative GraphQL schema definitions into strongly-typed Go source code, ensuring strict alignment between the API contract and the underlying implementation. The framework distinguishes itself through its deep integration with the Go type system and its highly extensible build pipeline. By using schema-first development, it automates the creation of server boilerplate and resolver stubs, allowing developers to map schema fields directly to Go structs and

SpringBoot-Labs is a collection of educational resources and reference implementations for Java backend architecture and distributed systems. It provides practical lab guides and code samples focused on building applications with the Spring Boot framework and designing scalable microservices architectures. The project specifically covers service governance and distributed cloud deployment patterns using Spring Cloud and Spring Cloud Alibaba. It includes a dedicated kit for microservices and a guide for executing remote procedure calls and managing service discovery via the Dubbo protocol. Th

Elysia is a high-performance TypeScript web framework designed for building type-safe backend services. It provides a modular, plugin-based architecture that allows developers to compose server logic, middleware, and validation schemas into scalable application instances. By leveraging native web standards, the framework ensures portability across diverse JavaScript runtimes, including Node.js, Deno, and various edge computing environments. The framework distinguishes itself through its focus on end-to-end type safety, automatically synchronizing request and response definitions between the s

Hug is a type-driven Python web framework designed for building APIs. It uses Python type annotations to automatically validate and convert incoming request data and to format outgoing responses. The framework functions as an automated documentation tool by extracting function signatures and markers from source code to generate accessible API specifications. It also supports non-blocking coroutines for asynchronous API processing to handle background tasks without interrupting the main request cycle. The project provides capabilities for REST API development, including route mapping, endpoin

Connexion is a spec-first Python web framework designed to derive server behavior and validation logic directly from a predefined API contract. It enables the development of web services by using an OpenAPI specification to automatically handle routing, request validation, and response serialization. The framework distinguishes itself by acting as an OpenAPI request validator and mock server. It can simulate API behavior by serving example responses based on specification schemas, allowing for frontend development and prototyping before a backend implementation is completed. Additionally, it

Apache Dubbo Go is a Go language implementation of the Apache Dubbo framework designed for building high-performance microservices. It serves as a cross-language RPC framework and microservices communication layer that enables remote procedure calls between services written in different programming languages. The framework functions as a service governance toolset and a distributed service mesh proxy, allowing data planes to connect with external control planes in proxy or proxyless modes. It specifically provides a compatibility layer to facilitate communication between Go and Java-based ser