Open-source alternatives to Tarpc

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

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

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

Rest_rpc is a C++20 remote procedure call framework designed for building distributed services. It provides an asynchronous service interface that allows developers to expose local functions as network-accessible services, enabling remote clients to trigger tasks through automated serialization and communication protocols. The framework distinguishes itself by leveraging template metaprogramming to perform compile-time type introspection, which generates binary encoders and decoders without the need for runtime reflection. It further optimizes network throughput through zero-copy buffer manag

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

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

Dubbo is a high-performance Java remote procedure call framework and microservice governance platform. It enables communication between distributed services using a remote service orchestrator and a distributed service registry to locate available providers in real time. The system provides a microservice monitoring suite for health tracking and distributed tracing, alongside integrated security plugins for access control. It manages network traffic through routing strategies, rate limiting, and thread pool isolation to maintain system stability. The framework covers broader capabilities in

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

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

CapnProto is a zero-copy serialization framework and remote procedure call system. It serves as a C++ communication library providing a schema-based data interchange format that eliminates the need to encode or decode data before reading it from memory. The system enables high-performance data serialization and low-latency network communication. It supports cross-language data exchange by using a defined schema to ensure consistent binary representation across different platforms. The framework provides tools for implementing remote procedure calls, allowing functions to be invoked on a remo

Snowflake is a high-concurrency RPC framework and distributed ID generation service. It provides the infrastructure to create unique, time-ordered identifiers across a network of servers and facilitates the development of network services designed to handle massive volumes of simultaneous requests. The system separates low-level transport logic from application behavior, allowing for the implementation of custom RPC protocols. It includes a distributed request tracing tool to visualize execution flow across network boundaries and a server lifecycle management interface to adjust logging level

This project is an educational framework designed to teach the fundamentals of building core distributed systems and web services from scratch in Go. It provides a collection of modular implementations that demonstrate how to construct essential infrastructure components, including web servers, remote procedure call systems, distributed caches, and database abstraction layers. The framework distinguishes itself by focusing on the internal mechanics of these systems rather than providing a high-level abstraction for production use. It covers the implementation of complex architectural patterns

This project is a comprehensive performance programming guide and reference for the Go language, focusing on runtime efficiency and memory optimization. It provides a collection of patterns and techniques designed to increase execution speed by reducing garbage collection overhead and optimizing memory usage. The resource distinguishes itself through detailed reference implementations for memory optimization, such as escape analysis, object pooling, and structure memory alignment. It offers specific strategies for reducing binary size and improving CPU cache efficiency through structure memor

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

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

FastStream is an asynchronous Python framework designed for building event-driven microservices. It provides a unified abstraction layer for interacting with various message brokers, enabling developers to manage event production and consumption through a consistent interface while maintaining access to native provider-specific features. The framework centers on a decorator-based routing model that binds application logic directly to broker topics, supported by a built-in dependency injection container that resolves resources at runtime. The framework distinguishes itself through its deep int

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

Quarkus is a Kubernetes-native Java framework designed for building high-performance, memory-efficient applications. It utilizes ahead-of-time native compilation to transform Java code into standalone, optimized binaries that eliminate the need for a virtual machine, enabling rapid startup and reduced memory consumption. By performing code augmentation during the build phase, it shifts heavy processing tasks away from runtime, ensuring that applications are optimized for cloud-native environments. The framework distinguishes itself through a unified approach to reactive and imperative program

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

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-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

This is a remote procedure call framework built on Netty for asynchronous communication between distributed services. It provides the infrastructure necessary to execute remote procedure calls across a network, allowing clients and servers to interact without blocking. The framework utilizes Zookeeper for service registration and dynamic discovery, ensuring that service providers can be located automatically at runtime. It includes a service versioning manager to organize and track different iterations of service interfaces, enabling side-by-side deployments of multiple versions. The system

sofa-rpc is a Java-based remote procedure call framework designed for executing remote functions and exchanging data between distributed applications. It serves as a distributed service orchestrator and communication tool, providing a registry-integrated manager to locate and track active network endpoints across a cluster. The framework is built with an interface-based plugin architecture, allowing internal logic and RPC behaviors to be customized through abstraction interfaces. This extensibility enables the implementation of specialized business logic without modifying the core system. Th

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

LearningNotes is a technical knowledge base and engineering study guide focused on Android framework internals, system architecture, and mobile performance optimization. It serves as a reference for analyzing the Android boot sequence, process bootstrapping, and system service initialization. The project provides detailed guides on mobile performance, including strategies for reducing memory footprints, identifying memory leaks, and optimizing image decoding. It further covers Android inter-process communication using AIDL and the Binder kernel driver, as well as software architecture manuals

go-plugin is a framework for implementing plugin architectures where extensions run as separate processes and communicate via a Go RPC plugin system. It functions as an inter-process communication library and lifecycle manager that allows host applications to discover, launch, and monitor external binary plugins. The framework enables cross-language plugin systems, allowing plugins written in different languages to integrate with a host through standardized RPC protocols. It features a bidirectional RPC bridge that allows both the host and the plugin to exchange interface implementations for

Cellnet is a Go networking framework designed for building distributed systems and peer-to-peer networks. It provides a multi-protocol transport layer that standardizes message exchange across TCP, UDP, and WebSockets, utilizing a binary message codec system to map message types to unique identifiers for network transmission. The framework is distinguished by its remote procedure call library, which enables the execution of functions on remote peers using synchronous or asynchronous request patterns. It further differentiates itself with an asynchronous event dispatcher that processes network