gRPC Blog

Interceptors in gRPC-Web

Zhenli Jiang

June 18, 2020

We’re pleased to announce support for interceptors in gRPC-web as of release 1.1.0. While the current design is based on gRPC client interceptors available from other gRPC languages, it also includes gRPC-web specific features that should make interceptors easy to adopt and use alongside modern web frameworks. Introduction Similar to other gRPC languages, gRPC-web supports unary and server-streaming interceptors. For each kind of interceptor, we’ve defined an interface containing a single intercept() method:

Announcing gRPC-JS 1.0

Michael Lumish

April 20, 2020

We are excited to announce the release of version 1.0 of gRPC-JS (@grpc/grpc-js), a pure-TypeScript reimplementation of the original Node gRPC library, grpc. Features gRPC-JS supports the following features, which should cover most use cases: Clients Automatic reconnection Servers Streaming Metadata Partial compression support: clients can decompress response messages Pick first and round robin load balancing policies Client Interceptors Connection Keepalives HTTP Connect support (proxies) Should I use @grpc/grpc-js or grpc?

Kotlin, meet gRPC

Louis Wasserman, Brent Shaffer

April 16, 2020

As developers work to modernize applications, they need foundational tools that are simple and scalable. gRPC is a high-performance, open-source, universal RPC framework originally developed at Google that developers are adopting in tremendous numbers, helping them connect services more easily and reliably. Paired with Kotlin, the second most popular JVM-based programming language in the world, developers can build everything from mobile apps to cloud microservices. To help, we’ve open-sourced gRPC Kotlin for the JVM, allowing you to use gRPC with your Kotlin projects.

gRPC comes to Cloud Run

Richard Belleville, Wenlei He

March 17, 2020

Cloud Run is a serverless platform offered by Google Cloud that lets you run stateless server containers in a fully managed environment. Most Cloud Run apps use HTTP JSON REST to serve requests, but since September 2019, apps can also use unary gRPC services!

Improvements to gRPC's CMake Build System

Zack Galbreath

March 16, 2020

For the past few months, Kitware Inc. has been working with the gRPC team to improve gRPC’s CMake support. The goal of the effort was to modernize gRPC’s CMake build with the most current features and techniques CMake has to offer. This has improved the user experience for gRPC developers choosing to use gRPC’s CMake as a build system. During the effort the CMake build was looked at as a whole, and CMake related issues in GitHub were explored and resolved.

.NET Core ❤ gRPC

Sourabh Shirhatti

September 23, 2019

The .NET team at Microsoft has been working in close collaboration with the gRPC team since November 2018 on a new fully managed implementation of gRPC for .NET Core. We’re pleased to announce that grpc-dotnet is now available with .NET Core 3.0 today! How to get it? grpc-dotnet packages have just been released to and are already available for use in your projects. These packages also require the latest .

Dear gRPC

April Nassi

March 8, 2019

Dear gRPC, We messed up. We are so sorry that we missed your birthday this year. Last year we celebrated with cake and fanfare, but this year we dropped the ball. Please don’t think that we love you any less. You’re 4 now and that’s a big milestone! You’re part of so much amazing technology at companies like Salesforce, Netflix, Spotify, Fanatics, and of course, Google. In fact just this week the biggest API Google has went production-ready with gRPC.

The state of gRPC in the browser

Johan Brandhorst

January 8, 2019

gRPC 1.0 was released in August 2016 and has since grown to become one of the premier technical solutions for application communications. It has been adopted by startups, enterprise companies, and open source projects worldwide. Its support for polyglot environments, focus on performance, type safety, and developer productivity has transformed the way developers design their architectures.

Visualizing gRPC Language Stacks

Carl Mastrangelo

December 11, 2018

Here is a high level overview of the gRPC Stacks. Each of the 10 default languages supported by gRPC has multiple layers, allowing you to customize what pieces you want in your application.

gRPC-Web is Generally Available

Luc Perkins, Stanley Cheung, Kailash Sethuraman

October 23, 2018

We are excited to announce the GA release of gRPC-Web, a JavaScript client library that enables web apps to communicate directly with gRPC backend services, without requiring an HTTP server to act as an intermediary. “GA” means that gRPC-Web is now Generally Available and stable and qualified for production use.

A short introduction to Channelz

Yuxuan Li

September 5, 2018

Channelz is a tool that provides comprehensive runtime info about connections at different levels in gRPC. It is designed to help debug live programs, which may be suffering from network, performance, configuration issues, etc. The gRFC provides a detailed explanation of channelz design and is the canonical reference for all channelz implementations across languages. The purpose of this blog is to familiarize readers with channelz service and how to use it for debugging issues. The context of this post is set in gRPC-Go, but the overall idea should be applicable across languages. At the time of writing, channelz is available for gRPC-Go and gRPC-Java. Support for C++ and wrapped languages is coming soon.

gRPC on HTTP/2 Engineering a Robust, High-performance Protocol

Jean de Klerk

August 20, 2018

In a previous article, we explored how HTTP/2 dramatically increases network efficiency and enables real-time communication by providing a framework for long-lived connections. In this article, we’ll look at how gRPC builds on HTTP/2’s long-lived connections to create a performant, robust platform for inter-service communication. We will explore the relationship between gRPC and HTTP/2, how gRPC manages HTTP/2 connections, and how gRPC uses HTTP/2 to keep connections alive, healthy, and utilized.


Carl Mastrangelo

August 15, 2018

So you’ve bought into this whole RPC thing and want to try it out, but aren’t quite sure about Protocol Buffers. Your existing code encodes your own objects, or perhaps you have code that needs a particular encoding. What to do?

Fortunately, gRPC is encoding agnostic! You can still get a lot of the benefits of gRPC without using Protobuf. In this post we’ll go through how to make gRPC work with other encodings and types. Let’s try using JSON.

Take the gRPC Survey!

Kailash Sethuraman

August 14, 2018

The gRPC Project wants your feedback!

The gRPC project is looking for feedback to improve the gRPC experience. To do this, we are running a gRPC user survey. We invite you to participate and provide input that will help us better plan and prioritize.

Gracefully clean up in gRPC JUnit tests

Dapeng Zhang

June 26, 2018

It is best practice to always clean up gRPC resources such as client channels, servers, and previously attached Contexts whenever they are no longer needed.

This is even true for JUnit tests, because otherwise leaked resources may not only linger in your machine forever, but also interfere with subsequent tests. A not-so-bad case is that subsequent tests can’t pass because of a leaked resource from the previous test. The worst case is that some subsequent tests pass that wouldn’t have passed at all if the previously passed test had not leaked a resource.

gRPC Meets .NET SDK And Visual Studio: Automatic Codegen On Build

Kirill 'kkm' Katsnelson

June 26, 2018

As part of Microsoft’s move towards its cross-platform .NET offering, they have greatly simplified the project file format, and allowed a tight integration of third-party code generators with .NET projects. We are listening, and now proud to introduce integrated compilation of Protocol Buffer and gRPC service .proto files in .NET C# projects starting with the version 1.17 of the Grpc.Tools NuGet package, now available from

gRPC ❤ Kotlin

Spencer Fang

June 19, 2018

Did you know that gRPC Java now has out of box support for Kotlin projects built with Gradle? Kotlin is a modern, statically typed language developed by JetBrains that targets the JVM and Android. It is generally easy for Kotlin programs to interoperate with existing Java libraries. To improve this experience further, we have added support to the protobuf-gradle-plugin so that the generated Java libraries are automatically picked up by Kotlin. You can now add the protobuf-gradle-plugin to your Kotlin project, and use gRPC just like you would with a typical Java project.

So You Want to Optimize gRPC - Part 2

Carl Mastrangelo

April 16, 2018

How fast is gRPC? Pretty fast if you understand how modern clients and servers are built. In part 1, I showed how to get an easy 60% improvement. In this post I show how to get a 10000% improvement.

So You Want to Optimize gRPC - Part 1

Carl Mastrangelo

March 6, 2018

A common question with gRPC is how to make it fast. The gRPC library offers users access to high performance RPCs, but it isn’t always clear how to achieve this. Because this question is common enough I thought I would try to show my thought process when tuning programs.

gRPC and Deadlines

Gráinne Sheerin

February 26, 2018

TL;DR: Always set a deadline. This post explains why we recommend being deliberate about setting deadlines, with useful code snippets to show you how.

gRPC-Go Engineering Practices

Doug Fawley

January 22, 2018

It’s the start of the new year, and almost the end of my first full year on the gRPC-Go project, so I’d like to take this opportunity to provide an update on the state of gRPC-Go development and give some visibility into how we manage the project. For me, personally, this is the first open source project to which I’ve meaningfully contributed, so this year has been a learning experience for me. Over this year, the team has made constant improvements to our work habits and communication. I still see room for improvement, but I believe we are in a considerably better place than we were a year ago.

The gRPC Meetup Kit

Mark Mandel, Sandeep Dinesh

September 14, 2017

If you have ever wanted to run an event around gRPC, but didn’t know where to start, or weren’t sure what content is available - we have released the gRPC Meetup Kit! The meetup kit includes a 15 minute presentation on the basic concepts of gRPC, with accompanying slides and video for either reference or playback, as well as a 45-minute codelab that takes you through the basics of gRPC in Node.

gRPC-Go performance Improvements

Mahak Mukhi

August 22, 2017

For past few months we’ve been working on improving gRPC-Go performance. This includes improving network utilization, optimizing CPU usage and memory allocations. Most of our recent effort has been focused around revamping gRPC-Go flow control. After several optimizations and new features we’ve been able to improve quite significantly, especially on high-latency networks. We expect users that are working with high-latency networks and large messages to see an order of magnitude performance gain. Benchmark results at the end.

This blog summarizes the work we have done so far (in chronological order) to improve performance and lays out our near-future plans.

2017-08-17 Community Meeting Update

Mya Pitzeruse

August 17, 2017

Next Community Meeting: Thursday, August 31, 2017 11am Pacific Time (US and Canada)

Announcing out-of-the-box support for gRPC in the Flatbuffers serialization library

Wouter van Oortmerssen

August 17, 2017

The recent release of Flatbuffers version 1.7 introduced truly zero-copy support for gRPC out of the box.

Flatbuffers is a serialization library that allows you to access serialized data without first unpacking it or allocating any additional data structures. It was originally designed for games and other resource constrained applications, but is now finding more general use, both by teams within Google and in other companies such as Netflix and Facebook.

gRPC Load Balancing


June 15, 2017

This post describes various load balancing scenarios seen when deploying gRPC. If you use gRPC with multiple backends, this document is for you.

A large scale gRPC deployment typically has a number of identical back-end instances, and a number of clients. Each server has a certain capacity. Load balancing is used for distributing the load from clients optimally across available servers.

gRPC in Helm

Brian Hardock

May 15, 2017

Helm is the package manager for Kubernetes. Helm provides its users with a customizable mechanism for managing distributed applications and controlling their deployment.

I have the good fortune to be a member of the phenomenal open-source Kubernetes Helm community serving as a core contributor. My first day working with the Helm team was spent prototyping the architecture for the next generation of Helm. By the end of that day, we had procured the preliminary RPC protocol data model used to enable communication between Helm and its in-cluster server component, Tiller.

Migration to Google Cloud Platform — gRPC & grpc-gateway

Miguel Mendez

April 12, 2017

In our previous blog post we gave an overview of our migration to Google Cloud Platform from Amazon Web Services. In this post we will drill down into the role that gRPC and grpc-gateway played in that migration and share some lessons which we picked up along the way.

Building gRPC services with bazel and rules_protobuf

Paul Cody Johnston

October 13, 2016

gRPC makes it easier to build high-performance microservices by providing generated service entrypoints in a variety of different languages. Bazel complements these efforts with a capable and fast polyglot build environment.

rules_protobuf extends bazel and makes it easier develop gRPC services.


Robert Sayre, Melinda Lu

September 6, 2016

Our guest post today comes from Robert Sayre and Melinda Lu of VSCO.

Founded in 2011, VSCO is a community for expression—empowering people to create, discover and connect through images and words. VSCO is in the process of migrating their stack to gRPC.

Why we have decided to move our APIs to gRPC

Dale Hopkins

August 29, 2016

Vendasta started out 8 years ago as a point solution provider of products for small business. From the beginning we partnered with media companies and agencies who have armies of salespeople and existing relationships with those businesses to sell our software. It is estimated that over 30 million small businesses exist in the United States alone, so scalability of our SaaS solution was considered one of our top concerns from the beginning and it was the reason we started with Google App Engine and Datastore.

gRPC Project is now 1.0 and ready for production deployments

Varun Talwar

August 23, 2016

Today, the gRPC project has reached a significant milestone with its 1.0 release. Languages moving to 1.0 include C++, Java, Go, Node, Ruby, Python and C# across Linux, Windows, and Mac. Objective-C and Android Java support on iOS and Android is also moving to 1.0. The 1.0 release means that the core protocol and API surface are now stable with measured performance, stress tested and developers can rely on these APIs and deploy in production, they will follow semantic versioning from here.

Mobile Benchmarks

David Cao

July 26, 2016

As gRPC has become a better and faster RPC framework, we’ve consistently gotten the question, “How much faster is gRPC?” We already have comprehensive server-side benchmarks, but we don’t have mobile benchmarks. Benchmarking a client is a bit different than benchmarking a server. We care more about things such as latency and request size and less about things like queries per second (QPS) and number of concurrent threads. Thus we built an Android app in order to quantify these factors and provide solid numbers behind them.

gRPC with REST and Open APIs

Brandon Phillips

May 9, 2016

Our guest post today comes from Brandon Phillips of CoreOS. CoreOS builds open source projects and products for Linux Containers. Their flagship product for consensus and discovery etcd and their container engine rkt are early adopters of gRPC.

One of the key reasons CoreOS chose gRPC is because it uses HTTP/2, enabling applications to present both a HTTP 1.1 REST/JSON API and an efficient gRPC interface on a single TCP port (available for Go). This provides developers with compatibility with the REST web ecosystem, while advancing a new, high-efficiency RPC protocol. With the recent release of Go 1.6, Go ships with a stable net/http2 package by default.

gRPC - now with easy installation

Lisa Carey

April 4, 2016

Today we are happy to provide an update that significantly simplifies the getting started experience for gRPC.

Google Cloud PubSub - with the power of gRPC!

Lisa Carey

March 24, 2016

Google Cloud PubSub is Google’s scalable real-time messaging service that lets users send and receive messages between independent applications. It’s an important part of Google Cloud Platform’s big data offering, and is used by customers worldwide to build their own robust, global services. However, until now, the only way to use the Cloud PubSub API was via JSON over HTTP. That’s all changed with the release of PubSub gRPC alpha. Now users can access PubSub via gRPC and benefit from all the advantages it brings.

gRPC releases Beta, opening door for use in production environments

Mugur Marculescu

October 26, 2015

The gRPC team is excited to announce the immediate availability of gRPC Beta. This release marks an important point in API stability and going forward most API changes are expected to be additive in nature. This milestone opens the door for gRPC use in production environments. We’re also taking a big step forward in improving the installation process. Over the past few weeks we’ve rolled out gRPC packages to Debian Stable/Backports.

gRPC Motivation and Design Principles

Louis Ryan

September 8, 2015

Motivation Google has been using a single general-purpose RPC infrastructure called Stubby to connect the large number of microservices running within and across our data centers for over a decade. Our internal systems have long embraced the microservice architecture gaining popularity today. Having a uniform, cross-platform RPC infrastructure has allowed for the rollout of fleet-wide improvements in efficiency, security, reliability and behavioral analysis critical to supporting the incredible growth seen in that period.