gRPC is a modern, open-source, high-performance remote procedure call framework that, in the words of its own documentation, lets “a client application directly call a method on a server application on a different machine as if it were a local object.” Developers define a service and its methods, gRPC generates client and server code from that definition, and the framework handles the work of serializing arguments, transmitting them, and delivering return values. This makes it straightforward to build connected systems where components written in different languages communicate transparently.
By default, gRPC uses Protocol Buffers as both its interface definition language and its message serialization format. A developer writes a .proto file describing the service’s methods and the structure of their request and response messages, then runs the protoc compiler to generate strongly typed stubs in the target language. Beyond simple unary calls, gRPC supports streaming in several shapes: server streaming, client streaming, and bidirectional streaming, where both sides send sequences of messages over a single long-lived connection.
gRPC runs over HTTP/2, which gives it features that older RPC and HTTP/1.1-based APIs lacked: multiplexing many concurrent calls over one connection, binary framing, header compression, and full-duplex streaming. Combined with the compact binary encoding of Protocol Buffers, this transport makes gRPC efficient in both latency and bandwidth, which is a large part of why it is favored for high-volume internal service-to-service traffic.
The framework was developed at Google and announced publicly in early 2015. It generalized Stubby, an internal RPC system Google had used for years to connect its services, into an open framework that anyone could adopt. The main repository at github.com/grpc/grpc holds the core C-based implementation that underpins several language bindings, while other languages are maintained in companion repositories. gRPC later became a project of the Cloud Native Computing Foundation, aligning it with the broader cloud-native and Kubernetes ecosystem.
gRPC became a standard choice for communication among microservices, where its generated contracts, streaming support, and efficiency are well matched to internal east-west traffic. Because browsers cannot speak raw gRPC directly, the companion gRPC-Web project and proxy layers bridge it to browser clients. For many teams gRPC occupies the niche that SOAP once held for strongly typed, contract-driven service calls, but with a lighter, binary, HTTP/2-native design.