Open-source alternatives to Grpc Rust

Armeria is a Netty-based microservice framework used for building high-performance asynchronous services. It functions as a multi-protocol RPC server capable of exposing gRPC, Thrift, and REST services on a single unified port. The project is distinguished by its ability to run diverse communication protocols simultaneously and its integrated RPC debugging web console, which allows for the discovery and invocation of remote procedure calls via JSON. It also includes a gRPC to JSON transcoder to enable web client compatibility with Protobuf services. The framework provides a comprehensive sui

grpc-go is a Go language implementation of the gRPC framework, providing a remote procedure call library for high-performance service communication. It uses the HTTP/2 protocol to execute functions on remote servers as if they were local methods and utilizes protobuf service bindings to generate type-safe client and server code. The project features a bidirectional streaming transport that supports asynchronous, full-duplex message streams between clients and servers. This networking layer allows for various communication patterns, including client-to-server and server-to-client streaming, to

gRPC-Web is a JavaScript client library that enables browser applications to call gRPC services through an HTTP proxy, using Protocol Buffers for serialization. It provides a browser-based gRPC client that supports unary, server-streaming, and bidirectional streaming RPCs, along with a code generator that produces JavaScript and TypeScript client stubs from .proto service definitions. The library includes an interceptor framework for attaching cross-cutting logic like authentication and retries to client calls, and supports setting Unix timestamp deadlines on RPCs for server-side timeout enfo

libhv is a high-performance C/C++ network library and event-driven I/O framework used to build TCP, UDP, SSL, HTTP, WebSocket, and MQTT clients and servers. It provides a non-blocking event loop for managing network sockets, timers, and system signals across multiple threads. The project is distinguished by its integrated support for specialized network roles, including a full HTTP web server with RESTful routing and middleware, an MQTT messaging client for IoT communication, and the ability to implement SOCKS5 and HTTP proxies. It also features a reliable UDP implementation to ensure ordered

gRPC is a language-agnostic remote procedure call framework designed for high-performance communication between distributed services. It utilizes a structured interface definition language to generate consistent client stubs and server skeletons, enabling applications to invoke methods on remote servers as if they were local objects. By leveraging the HTTP/2 transport layer, the framework supports efficient binary serialization and multiplexed data exchange across diverse programming environments. The framework distinguishes itself through its support for flexible communication patterns, incl

brpc is a high-performance C++ RPC framework and network programming library designed for building distributed systems. It functions as a multi-protocol RPC server capable of hosting and detecting multiple communication protocols, including gRPC, Thrift, HTTP, Redis, and Memcached, on a single TCP port. The project distinguishes itself through high-throughput data transport and memory efficiency, utilizing RDMA-based transport to bypass the kernel TCP stack and zero-copy memory management to eliminate data duplication. It also implements the Raft algorithm for consensus-based state replicatio

Sofa-rpc is a high-performance remote procedure call framework designed for building distributed Java applications. It functions as a toolkit for managing a distributed service mesh, providing a gRPC communication layer and a system for registering and locating remote service instances. The framework features a network security layer that implements TLS encryption and authorization checks to protect data transmitted between services. It utilizes a pluggable protocol layer to support multiple communication standards, ensuring flexible point-to-point connectivity. Reliability and traffic manag

This project is an integration framework that bootstraps Apache Dubbo remote procedure call services within Spring Boot applications. It serves as a microservice communication framework that enables the implementation of RPC services, service discovery, and distributed governance through automated configuration. The project distinguishes itself by providing a cross-language RPC bridge, allowing services written in different languages to communicate via standards such as gRPC and Protobuf. It further enables the exposure of backend microservices as REST endpoints using the Triple protocol for

Cerbos is an open-source authorization service that provides a centralized, language-agnostic engine for managing access control. It functions as a policy-as-code platform, allowing teams to define, test, and distribute authorization rules using declarative YAML or JSON configurations. By decoupling access logic from application code, it enables consistent permission enforcement across diverse service stacks. The project distinguishes itself through its ability to translate high-level authorization policies into native database query filters. This capability allows applications to enforce sec

Emissary is a Kubernetes API gateway that manages incoming external traffic and routes it to internal microservices. It utilizes an Envoy proxy as the underlying data plane to handle high-performance traffic routing and protocol translation, with a control plane that translates Kubernetes custom resources and annotations into proxy configurations. The project provides specialized support for gRPC infrastructure, including HTTP/2 routing and gRPC-Web protocol bridging for browser-based clients. It enables zero-trust security through mutual TLS encryption and delegates identity verification to

Wire is a cross-platform code generator and implementation of gRPC and Protocol Buffers. It transforms schema definitions into type-safe native language bindings for Kotlin, Swift, and Java to ensure consistent data exchange and communication between distributed systems. The project provides specialized tools for protocol buffer schema management, including the ability to prune unused types and filter fields by version to reduce final binary sizes. It also handles namespace management and allows for the creation of custom schema handlers to execute user-defined logic during the compilation ph

Hertz is a high-performance Go HTTP framework designed for building scalable microservices, RESTful APIs, and AI applications. It functions as a high-performance web server and a communication framework for microservices, utilizing non-blocking I/O and zero-copy memory management to handle high-concurrency traffic. The project distinguishes itself through a microservices communication toolkit that supports high-efficiency remote procedure calls via gRPC and Thrift protocols. It implements an asynchronous middleware engine based on an onion model, allowing for a pluggable request-response pipe

Prost is a Protocol Buffers implementation for Rust that functions as a binary serialization framework and code generator. It translates schema definitions into idiomatic Rust structs and enums, providing the logic necessary to encode and decode structured data into the Protocol Buffers binary format. The project distinguishes itself through a no-std implementation, allowing it to operate in embedded or kernel environments that lack a standard library. It also serves as a schema introspector by emitting file descriptor sets, which enables the programmatic analysis of original schema definitio

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

Handy is a C++11 network server framework and event-driven networking engine designed for building high-performance concurrent TCP and UDP servers. It functions as an asynchronous I/O library and an HTTP server implementation that separates asynchronous network I/O from synchronous business logic to simplify server development. The framework distinguishes itself by utilizing platform-specific event notifications to manage millions of simultaneous network connections and providing an SSL/TLS network wrapper for encrypted asynchronous data transmission. It implements a half-sync/half-async proc

MagicOnion is a remote procedure call framework for the .NET platform and Unity. It functions as a binary API protocol and real-time communication engine that uses shared interfaces to provide type-safe communication between clients and servers. The framework distinguishes itself through its compatibility with ahead-of-time compilation environments, utilizing source generators for client proxies and serialization to support mobile and console platforms including those using IL2CPP. It provides a specialized middleware layer for Unity that handles engine-specific data types and ensures runtime

This project is a MySQL database driver for Node.js that establishes network connections and executes SQL queries using a native communication protocol. It functions as an asynchronous SQL client, providing a promise-based query interface and support for async/await patterns to manage non-blocking database operations. The library includes a full MySQL protocol implementation, serving as a toolkit for building custom database servers, proxies, or clients. It also operates as a connection pool manager and an injection prevention tool, utilizing prepared statements and parameterized queries to s

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

NATS Server is a high-performance, lightweight messaging system designed for cloud-native applications, edge computing, and distributed microservices. It functions as a distributed publish-subscribe broker that routes messages using hierarchical, dot-separated subject strings, enabling decoupled communication between services without requiring centralized broker lookups. The system supports core messaging patterns including asynchronous publish-subscribe, request-reply, and load-balanced queue processing. The platform distinguishes itself through a decentralized architecture that eliminates t

Vector is a high-performance observability data pipeline designed to collect, transform, and route logs, metrics, and traces across distributed infrastructure. It functions as a modular engine that decouples data ingestion from processing and transmission, utilizing a component-based architecture to connect diverse sources to multiple destinations. The project distinguishes itself through a focus on reliability and flow control. It implements backpressure-aware data movement to prevent data loss during traffic spikes and utilizes disk-backed event buffering to ensure durability during network

Prototool is a development toolkit for Protocol Buffers that provides a suite of tools for linting, formatting, and generating code from schema files. It functions as a system for managing the lifecycle of Protocol Buffer definitions through a command line interface. The toolkit distinguishes itself by providing a breaking change detector that compares different versions of definitions to identify wire or source incompatible changes. It also includes a gRPC client interface capable of invoking endpoints using JSON requests by dynamically compiling Protobuf definitions. The project covers bro

grpc-web is a translation layer and proxy system that enables web browsers to communicate with gRPC backend services. It consists of a gRPC Web Proxy that converts browser-based HTTP and WebSocket requests into standard gRPC calls, along with a TypeScript gRPC client for making strongly-typed remote procedure calls from browsers or Node.js environments. The project features a bidirectional streaming bridge that utilizes WebSockets to bypass browser limitations, allowing for full-duplex communication and client-side data streaming. It includes a protocol buffer code generator that parses schem

This project is a reference implementation of Domain-Driven Design, Clean Architecture, and Command Query Responsibility Segregation (CQRS) patterns using the Go programming language. It serves as a sample application to demonstrate how to decouple core domain rules from infrastructure and delivery mechanisms. The system is built as a gRPC microservices architecture, utilizing type-safe communication and service contracts. It implements an event-driven architecture to manage eventual consistency and asynchronous processing, specifically employing the Outbox pattern to ensure reliable messagin

Golang-100-Days is a structured, daily lesson curriculum for learning the Go programming language from the ground up, progressing into practical microservice and web application development. The project is built around a code-example-driven approach, where each day introduces new concepts through runnable Go snippets and complete project examples rather than abstract theory, covering Go fundamentals such as syntax, data types, control flow, functions, and packages. The curriculum differentiates itself by grouping lessons around specific Go frameworks and distributed system patterns. It includ

lan-mouse is a software KVM switch and networked peripheral controller that allows a user to share a single keyboard and mouse across multiple computers over a local area network. It functions as a cross-platform input sharer, capturing local peripheral events and relaying them to remote hosts for simulation at the operating system level. The system secures remote input control using a TLS-encrypted transport layer to prevent the interception of keystrokes and pointer data. Access is managed through fingerprint-based device authorization, which validates remote connections by matching unique

This project is a Protocol Buffers Go compiler and code generation framework that translates schema definitions into optimized Go structures and reflection-free serialization methods. It includes a gRPC service generator for producing client and server communication code and a serialization performance toolkit for generating automated benchmarks and test suites. The framework features a plugin-based system for transforming data definitions into source code with custom field mapping and struct tag injection. It allows for custom type mapping and struct type overriding to link data fields to sp

Pinot is a distributed, columnar analytical database designed for high-concurrency, low-latency query processing. It functions as a real-time OLAP datastore, enabling interactive, user-facing analytics by ingesting and querying massive datasets from both streaming and batch sources. The system architecture relies on a centralized controller for cluster coordination and a distributed segment-based storage model to ensure horizontal scalability. The platform distinguishes itself through a hybrid ingestion pipeline that unifies real-time event streams and historical batch data into a single quer