Open-source alternatives to Grpc Dotnet

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

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

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

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

Connect-go is a library for building type-safe remote procedure call services that are wire-compatible with gRPC and HTTP. It provides a Go implementation of Protocol Buffers for structured data exchange, enabling the creation of multi-protocol RPC servers and generated type-safe clients. The framework is distinguished by its polyglot protocol support, allowing a single server handler to serve requests using several different protocols simultaneously over HTTP. This includes the ability to toggle between different transport protocols for the same service and the use of pluggable content negot

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

userver is a comprehensive C++ backend application platform and asynchronous framework designed for building scalable microservices. It provides a high-performance execution environment for deploying services that communicate via gRPC and HTTP using a middleware-based request pipeline. The platform distinguishes itself through a distributed service orchestration toolset that manages shared state, distributed locking, and dynamic configuration updates without requiring process restarts. It utilizes a coroutine-based asynchronous execution model and event-loop network I/O to handle high-concurr

This library provides a framework for implementing gRPC clients and services in Rust, enabling reliable communication between distributed system components. It facilitates the definition and hosting of asynchronous unary and streaming network services, utilizing protocol buffers to ensure consistent, strongly-typed data exchange. The project distinguishes itself by integrating with a high-performance C core via foreign function interfaces to handle low-level networking and protocol logic. It employs a task-based concurrency model to coordinate non-blocking operations and utilizes zero-copy me

This project is a microservice framework for building scalable backend systems in Go. It provides an architecture for distributed systems with integrated support for service discovery, load balancing, and fault-tolerance mechanisms. The framework distinguishes itself through a domain-driven layered architecture and a remote-first configuration system that synchronizes settings between remote stores and local files with automatic failover. It implements a high-performance communication model using gRPC for unary and streaming data exchange, as well as real-time notification systems for managin

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

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

Twirp is a Protocol Buffers RPC framework designed for implementing type-safe, distributed microservices communication over HTTP. It functions as a microservices communication framework and API code generator that produces strongly typed client stubs and server interfaces from schema definitions to eliminate manual network boilerplate. The framework ensures compatibility with existing web infrastructure by executing remote procedure calls over standard HTTP transport. It uses schema-driven contracts as a single source of truth to enable cross-language interoperability and decouple business lo

grpcurl is a command-line interface and client tool for invoking gRPC methods and inspecting service definitions. It serves as a server debugger and reflection client, allowing users to call remote procedures and verify server responses from the terminal using JSON or protobuf formats. The tool distinguishes itself through the ability to discover available services and methods dynamically via a server reflection service or by loading local protobuf schema files. It can extract service descriptions from a server for local use and print specific schema symbol definitions. It covers a broad ran

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

rpcx is a high-performance remote procedure call framework for building scalable microservices in Go. It functions as a binary protocol RPC system and a service mesh, providing the necessary infrastructure for low-latency inter-service communication and distributed cloud environments. The project features a cross-language service gateway that provides an HTTP entry point, allowing clients written in any programming language to invoke Go remote services via protocol translation. It also includes a specialized RPC traffic analyzer for capturing and analyzing binary packets to debug network comm

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

go-grpc-middleware is a gRPC middleware framework for Go designed to handle cross-cutting concerns, reliability, and observability. It provides a collection of interceptors that can be used to modify inbound and outbound calls to enforce system-wide policies. The framework distinguishes itself through specialized toolkits for service reliability, including automatic retry logic for failed client calls and panic recovery mechanisms that translate runtime crashes into standard error responses. It also features an observability suite for collecting performance metrics and recording request activ

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

Nameko is a Python microservices framework designed for building distributed systems. It functions as an RPC communication framework and an event-driven architecture tool, using a message broker to decouple isolated service components. The framework provides a multi-protocol gateway that exposes internal microservice logic to external clients via HTTP endpoints and websockets. It enables the exchange of request-response messages and the broadcasting of asynchronous events to maintain data consistency across a distributed system. The system includes a command line interface for controlling an

grpcui is a browser-based interactive web interface and API client for executing remote procedure calls to gRPC servers. It functions as an HTTP to gRPC gateway that translates JSON payloads into binary protobuf messages, allowing users to trigger network requests and inspect responses through a visual web interface. The tool provides schema browsing and discovery capabilities by querying server reflection or loading local protobuf descriptor files to identify available services and method signatures. It uses these definitions to automatically generate dynamic input forms for constructing req

MagicOnion is a .NET RPC framework used to build type-safe remote procedure call services using shared interfaces for communication between servers and clients. It functions as a binary serialization framework and a distributed service orchestrator, providing a network layer for low-latency streaming and real-time data exchange. The project distinguishes itself through an AOT-compatible network client that uses source generators to support ahead-of-time compilation in restricted runtime environments. It enables bidirectional communication and real-time data streaming, allowing servers and mul

This project is a collection of reference implementations and demonstration projects covering computer vision, DevOps automation, distributed systems, and Java-based microservices. It provides a programming reference library and practical examples for building server-side applications, containerizing services, and orchestrating clusters. The repository features a comprehensive toolset for DevOps automation, including scripts and playbooks for CI/CD pipelines and automated cluster installation. It includes a computer vision demo project for image object detection and facial analysis, as well a

Goravel is a full-featured development scaffold and framework for building web applications, REST APIs, and gRPC services using the Go programming language. It implements a model-view-controller architecture and provides a comprehensive toolkit for high-performance remote procedure call servers and clients. The framework is distinguished by its extensive integrated ecosystem, which includes a fluent object-relational mapper for database management and a dedicated command-line interface toolkit for administrative automation and project scaffolding. It features a driver-based service abstractio

Dubbo is a Java RPC framework and microservices governance platform designed for high-performance remote procedure calls in distributed architectures. It provides the foundational components necessary to connect distributed services across a network, including a binary data serialization library and a distributed service registry. The platform distinguishes itself through a comprehensive governance suite that manages service discovery, load balancing, and traffic routing. It enables precise control over network traffic via conditional routing and a pluggable extension mechanism based on a ser

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

Ribbon is a client-side load balancer and RPC communication library designed for inter-process communication. It functions as a fault-tolerant network proxy that distributes outgoing network requests across a pool of available server instances to prevent node overload. The project integrates as a service discovery client, maintaining synchronized lists of available server instances by connecting with cloud environment discovery tools. This allows it to manage request retries and failover behavior when remote servers become unresponsive. The library supports a protocol-agnostic transport laye

Poem is a comprehensive toolkit for building type-safe web applications, APIs, and servers using the Rust programming language. It provides a foundation for developing web servers that handle HTTP requests with strong type safety. The framework distinguishes itself by supporting multiple communication protocols through a protocol-agnostic handler mapping. This allows a single internal logic to be exposed across HTTP, gRPC services using protobuf definitions, and the Model Context Protocol for AI model integration. Additionally, it includes built-in tooling for generating OpenAPI v3 specificat