Schedule

BREAKFAST

• Chicken Sausage Breakfast Burrito: chicken sausage, potatoes, scrambled eggs, cheese, pico de gallo, salsa rojo (NF)

• Vegan Breakfast Burrito: soyrizo, potatoes, vegan cheese, chunky salsa (Vegan)

• Fresh Fruit Cups (Vegan, DF, NF, GF)

Kick-off Keynote session for gRPConf 2026

Find out about the latest developments and a look ahead for gRPC.

Dive into the world of gRPC, a modern, open-source Remote Procedure Call (RPC) framework that's transforming how distributed systems communicate. This session will provide a comprehensive overview of gRPC, highlighting its core principles, benefits, and practical use cases. We'll explore how gRPC leverages HTTP/2 for efficient, bi-directional streaming and Protocol Buffers for language-agnostic, strongly-typed data serialization. Whether you're building microservices, real-time applications, or polyglot environments, discover why gRPC is a powerful choice for high-performance, low-latency communication.

An overview of how gRPC is evolving to become a foundational component of global-scale AI deployments.

AM SNACK

• Yogurt Parfait Cups: yogurt, fresh berries, house granola, agave syrup (Vegetarian)

• Mini Muffins (Vegetarian)

At Netflix, we use gRPC as our primary service-to-service framework, supporting traffic for over a thousand clients and services. To function effectively at this scale demands a rich
feature stack that’s built to handle failures gracefully.

In this talk, we’ll delve into how we build on top of open source gRPC to deliver key resiliency features: fallbacks for graceful degradation, deadline propagation across IPC transports, hedged requests to trim tail latency, custom request routing for safe traffic experiments, real-time configuration changes with minimal downtime, and how we provide abstractions that let engineers focus on their services rather than boilerplate.

You'll walk away with an understanding of how we make gRPC reliable in production at Netflix's scale.

gRPC is more than just a protocol: it's an opinionated set of tools and recommended ways to build servers and clients of networked APIs. But what if you have different opinions? Not all of us work in Google-scale contexts with monorepos containing thousands of services, strict controls over those implementations, and a fleet of engineers to keep them all up-to-date.

Sidecar is a Go library that supports gRPC wire protocols in the most minimal way possible: using the Go standard library and virtually no external dependencies. Originally created to communicate with sidecar proxies over Linux abstract sockets, Sidecar builds on Go generics, concurrency primitives, and native HTTP2 support to make gRPC clear, simple, and maintainable.

Sidecar grew out of IO, a new Envoy controller that was created to bring the powers of service meshes to individual developers. We'll talk about how IO and Sidecar work together to create a new class of secure and maintainable applications.

Building a production-grade proxyless gRPC service mesh requires solving two problems. Most reference implementations offer little guidance on high availability, dynamic registration, or multi-instance coordination. And while unary gRPC clients benefit from xDS-driven discovery, load balancing, and failover, bidirectional streaming clients do not, the backend is picked once at stream open, and a failure means a lost stream.

This session presents a ground-up xDS control plane in Go: a gossip-based peer-to-peer mesh with dynamic service registration, multi-region failover, and a built-in management plane no sidecar required. It also covers extending these xDS capabilities to bidirectional gRPC connections, bringing streaming clients to parity with unary.

The talk walks through the control plane architecture, the registration and de-registration lifecycle, multi-region coordination, and the trade-offs in applying xDS semantics to long-lived streaming connections.

Learn about how to get started with gRPC-Java with members of the gRPC-Java team! In this hands-on codelab, you will learn about protocol buffers, gRPC Code Generation, and implementing servers and clients in Java.

By the end of this codelab, you'll have a solid understanding of the core gRPC concepts and the confidence to start integrating gRPC into your own Java projects.

gRPC is highly performant and easy to adopt, but in test and measurement environments it can hit latency and throughput limits caused by standard framing overheads and memory copies. This talk presents an architecture for accelerating gRPC without changing application APIs or protobuf contracts. It will cover a method where standard gRPC negotiates capabilities, then transparently upgrades eligible traffic to lower-latency transports, for example, shared memory on the same host or RDMA network paths across hosts. These methods enable sub 10us round trips and zero copy buffers. The session will cover support for unary and streaming calls, capability signaling, zero-copy buffer handling, and safe fallback to standard gRPC when low latency paths are unavailable. The presentation will cover practical design patterns and tradeoffs than can be applied to build faster, portable, and maintainable low latency gRPC systems.

Writing your own xDS control plane for gRPC services is much easier than you think! In this session, I will talk about how we build a custom xDS control plane for testing gRPC services with following topics:

• Basics of xDS and how gRPC services can use xDS for dynamic configuration.
• How our custom xDS control plane (https://github.com/kauche/cloud-run-service-router-xds) works for our testing environment based on pull requests, by dynamically propagating routing rules to gRPC services running in our cloud environment (Google Cloud Run).
• Basics of building a custom xDS control plane with go-control-plane and key findings for implementing a custom xDS control plane.

Traditional web applications utilize HTTP, functioning as opaque backends within gRPC/xDS service meshes and lacking native access to SPIFFE identity, mTLS, xDS routing, and advanced load balancing.
grpcgi resolves this by inverting the transport layer. Envoy communicates via gRPC to an in-process server that translates calls into the application's native interface (e.g., ASGI, Rack). This enables unmodified applications to operate over gRPC, directly inheriting the service mesh's security and routing infrastructure without code modifications.
This presentation examines the language-neutral bridge protocol alongside Envoy-side translation using proxy-wasm and a native C++ filter. It explores the implications of converting web applications—including AI inference servers—into first-class gRPC upstreams. The session concludes with a live demonstration of an unmodified web application and a WebSocket echo served via gRPC through Envoy with xDS and mTLS.

LUNCH

• Fresh Baked Ciabatta & Rosemary Sea Salt Focaccia with butter (Vegetarian, NF)
• Mixed Baby Greens Salad: arugula, roasted beets, grilled seasonal fruit, candied pepitas, goat cheese, white balsamic vinaigrette (Vegan without cheese, GF, NF)
• Roasted Baby Carrots & Broccolini (Vegan, DF, GF, NF)
• Autumn Wild Rice Pilaf: fresh herbs, butternut squash, caramelized cippolini onions (Vegetarian, GF, NF)
• Chicken Marsala with mushroom marsala cream sauce (NF)
• Lasagna Rollatini: butternut squash, mushrooms, spinach, ricotta, mozzarella, truffle cream sauce (Vegetarian, NF)

Come learn about many of the major new features that gRPC-Python is working on:
– fork support/ EventEngine
– no-GIL
– zero-Copy
– Type Hints
– Cython stable API

The author of Mantis Skills and gRPC team members will discuss how the gRPC team took a proactive stance on the new world of AI vulnerability identification.

Learn how the gRPC team worked with the author of the newly open-sourced Mantis Skills (a Portable Toolkit for Building Security Review Harnesses) to identify and address vulnerabilities across their codebase, and build up continuous vulnerability scanning across the gRPC languages.

Learn about how to get started with gRPC-Rust with members of the gRPC-Rust team! In this hands-on codelab, you will learn about protocol buffers, gRPC Code Generation, and implementing servers and clients in Rust.

Discuss and give feedback on the major new features that gRPC-Python is working on:
– fork support/ EventEngine
– no-GIL
– zero-Copy
– Type Hints
– Cython stable API

Come discuss how your project has been affected by the need to deal with AI vulnerability scanning.

The author of Mantis Skills and gRPC team members will discuss how the gRPC team took a proactive stance on the new world of AI vulnerability identification.

Learn how the gRPC team worked with the author of the newly open-sourced Mantis Skills (a Portable Toolkit for Building Security Review Harnesses) to identify and address vulnerabilities across their codebase, and build up continuous vulnerability scanning across the gRPC languages.

This advanced session shows how Gama (go-gRPC+Homa+Http3) implements high-performance gRPC in Go over raw Homa while also supporting HTTP/2 and HTTP/3 on the same service port. We will walk through architecture decisions, transport internals, TLS design (including Homa TLS 1.3 flow), and benchmarking patterns for unary and bidirectional streaming workloads. Through real user stories and case studies, we will cover what worked, what failed, and what changed in kernel, networking, and app layers to get reliable low-latency behavior. Attendees will leave with practical guidance to evaluate, prototype, and operate alternative RPC transports without abandoning existing gRPC service contracts.

The Kubernetes Container Runtime Interface is a gRPC API on every node. Its list operations used unary RPCs. That worked until nodes accumulated thousands of completed and failed containers. At that density, responses cross the receive limit, producing ResourceExhausted errors. Raising the limit only postpones the failure and does nothing about unbounded result sets.
The fix was adding six streaming RPCs to CRI and implementing them in CRI-O, with UNIMPLEMENTED-based fallback to unary during mixed-version rollout.
But streaming did not fix everything. gRPC provides flow control through HTTP/2, but the first implementation gathers the full result set before calling Send. Messages are smaller on the wire, but server memory stays roughly the same because flow control cannot help if everything is materialized first.
This case study from the CRI-O maintainer covers why unary broke, how rollout worked, and what pipeline streaming requires on the server side.

gRPC often looks simple at first: define a proto, generate a client, make a call. But once services become part of production infrastructure, beginners quickly discover that the hard parts are API boundaries, backward compatibility, deadlines, retries, observability, error models, and contracts that can evolve safely.
Drawing on real-world experience from cloud functions and serverless infrastructure work, this beginner-friendly session explains the practical gRPC design choices that matter before a service reaches production. The talk will not cover proprietary architecture or vendor-specific internals; it will translate production experience into reusable guidance for anyone building serious gRPC services.
Attendees will learn how to design proto messages for change, avoid compatibility mistakes, choose useful error patterns, set deadlines intentionally, and test services with open source tools such as grpcurl.

Learn about how to get started with gRPC-Python with members of the gRPC-Python team! In this hands-on codelab, you will learn about protocol buffers, gRPC Code Generation, and implementing servers and clients in Python.

By the end of this codelab, you'll have a solid understanding of the core gRPC concepts and the confidence to start integrating gRPC into your own Python projects.

Every gRPC engineer eventually faces a binary .pb blob of unknown type, a compiled descriptor with no .proto source, or an editions descriptor a downstream toolchain cannot consume. Standard tooling stops short: protoc –decode requires the original descriptor and exact type name, silently discards non-canonical bytes, crashes on malformed input.

prototools is a pair of open-source CLI tools that fill this gap.

prototext decodes binary protobuf with or without a schema. Given a descriptor DB, it automatically infers the message type — ranking all candidates from a corpus of thousands of types in seconds. It also preserves every non-canonical byte via inline annotations and round-trips byte-exact, even for malformed protobufs.

reproto reconstructs compilable .proto source files from any FileDescriptorSet, handling proto2, proto3, and editions. It also builds the indexed descriptor databases that power prototext's auto-inference.

The talk is built around a live terminal demo.

Proxyless xDS lets a gRPC client get its routing, load balancing, and traffic policy directly from an xDS control plane and connect straight to backends with no sidecar in request path. Go and Java have had this for years.
This talk is the story of building proxyless xDS for Rust gRPC at LinkedIn and running it in production. We'll start with part that shaped everything: how the state of the Rust gRPC ecosystem, Tonic and the absence of an official gRPC-Rust xDS stack led to our design, and choices that made it work in Rust. Then the production story on how we leveraged dual-mode channels to migrate services off sidecars to proxyless channel, and we'll also share concrete numbers along with operational wins.
With the solution proven in production, we partnered with the gRPC team at Google to bring it to wider community, upstreaming it into grpc-rust as two crates: xds-client and tonic-xds.
Attendees will leave understanding what proxyless xDS is, how it can fit the Rust gRPC ecosystem.

AI systems put unusual stress on service boundaries. A single user request can trigger long-lived sessions, fan out across services, hit external model backends, and produce latency patterns very different from traditional request-response APIs. gRPC then becomes part of how teams reason about observability, debugging, and production behavior.

This talk shows how to use gRPC service boundaries as the backbone for end-to-end AI inference tracing: which signals matter across AI-serving workflows, how to distinguish prefill-heavy from decode-heavy behavior, and how to expose telemetry that helps ML and infra teams understand what happened during a request.

Key takeaways:
– How AI inference changes observability needs across gRPC services
– Which telemetry signals help explain real inference behavior
– How to structure tracing so platform and ML teams can both use it

PM SNACK

• SkinnyPop popcorn
• Sea Salt Kettle Chips
• Fresh Baked Cookies: snickerdoodle, chocolate chip, oatmeal (Vegetarian, NF)

Hear from the gRPC-Rust team on our progress following our preview release as we move towards a stable release and offering more advanced functionality to be production ready.

Learn about how to get started with gRPC-Go with members of the gRPC-Go team! In this hands-on codelab, you will learn about protocol buffers, gRPC Code Generation, and implementing servers and clients in Go.
By the end of this codelab, you'll have a solid understanding of the core gRPC concepts and the confidence to start integrating gRPC into your own Go projects.

NETWORKING RECEPTION

Tray-Passed Hors d’Oeuvres
– Gouda Arancini: risotto, smoked gouda, red pepper coulis (Vegetarian, NF)
– Smoked Pear Crostini: pear butter, goat cheese, candied pecan (Vegetarian)
– Exotic Mushroom Tart: mushrooms, caramelized onions, truffle oil (Vegetarian, NF)
– Asian Vegetable Fresh Spring Roll: mango, mint, basil, rice paper, spicy peanut sauce (Vegan, DF)

Grazing Stations
– Antipasto Board: artisan meats, cheeses, pickled vegetables, dried fruits, roasted nuts, crackers (includes Vegan, Vegetarian, DF, GF, NF items)
– Vegetable Crudité: fresh vegetables, crostini, red pepper aioli, hummus, ranch (Vegan, DF, NF)

Dessert
– French Macarons: sea salt caramel, pistachio, raspberry, chocolate (Vegetarian, GF)
– Caramelized Apple Tart with salted caramel (Vegetarian, NF)