Pingora is Cloudflare Rust framework for building proxies and networked services

What Pingora is and how it is proven

Pingora is a Rust framework to build fast, reliable, and programmable networked systems. The README links this description to Cloudflare's pingora open source announcement. The project is battle tested because it has been serving more than 40 million Internet requests per second for more than a few years, according to Cloudflare's write up on how the proxy connects Cloudflare to the internet.

That scale is the strongest claim in the document. Rather than describing Pingora as a library someone might try, the README anchors it in production traffic at Cloudflare. The phrase "more than a few years" keeps the claim modest while still signaling long term use under real load.

Feature highlights

The README lists a set of feature highlights. These include async Rust for speed and reliability, HTTP 1 and 2 end to end proxying, and TLS over OpenSSL, BoringSSL, s2n tls, or rustls in experimental form. The framework also proxies gRPC and websocket traffic, supports graceful reload, offers customizable load balancing and failover strategies, and works with a variety of observability tools.

The TLS list is notable because it lets a team pick the SSL backend that fits its stack, with rustls kept experimental rather than presented as ready. Graceful reload matters for a proxy that must stay up during config or binary changes, and the customizable load balancing and failover hooks are what make the framework usable as a building block instead of a fixed product.

Why teams pick Pingora

The README gives three reasons to use Pingora. First, security is the top priority, and Pingora is a more memory safe alternative for services written in C or C++. Second, a performance sensitive service benefits because Pingora is fast and efficient. Third, extensive customization is supported because the APIs the proxy framework provides are highly programmable.

These map to the usual reasons teams reach for a Rust networking stack. Memory safety targets the class of bugs that plague C and C++ proxies, performance speaks to throughput per core, and programmability covers the cases where off the shelf proxy config is not enough. The README presents them as the core fit rather than a feature checklist.

The crates that make up the workspace

Pingora ships as a workspace of crates, each with a narrow job. The public facing crate is Pingora, which builds networked systems and proxies. Pingora core defines the protocols, functionalities, and basic traits. Pingora foundations handles telemetry integration, Pingora proxy holds the logic and APIs for HTTP proxies, and Pingora error, Pingora http, and the SSL crates cover error types, header definitions, and TLS extensions.

Beyond those, the workspace includes Pingora ketama for the Ketama consistent hashing algorithm, Pingora limits for efficient counting, Pingora load balancing for balancing extensions, Pingora memory cache for async in memory caching with a cache lock to prevent stampede, Pingora s2n for s2n tls, Pingora timeout for a more efficient async timer, and TinyUfo, the caching algorithm behind the memory cache. The README adds a caveat that proxy caching integration is experimental and its APIs are currently volatile.

System requirements and supported platforms

Linux is the tier 1 environment and main focus for Pingora. The team tries to keep most code compiling for Unix environments so developers on macOS and other Unix like systems have an easier time, though some features may be missing there. Windows support is preliminary and relies on the community's best effort only. Both x86_64 and aarch64 architectures are supported.

This platform stance is typical of a server side Rust project. Production users are expected on Linux, while macOS is a development convenience and Windows is not a first class target. The split helps set expectations about where Pingora is safe to run in production, and it tells contributors which platforms get the most testing.

Rust version and build tooling

Pingora keeps a rolling minimum supported Rust version policy of 6 months. The project accepts pull requests that raise the MSRV as long as the new Rust version is at least 6 months old, but it will not bump the highest MSRV across the workspace without a strong reason. The current MSRV is 1.85, and not every crate enforces rust version, since some crates can be used on lower versions.

Building has two extra tool requirements. Clang must be installed for BoringSSL, and Perl 5 must be installed for OpenSSL. These come from the TLS backends the framework links, so a clean build depends on having the system tools present before compiling the SSL related crates. The README points to the Clang and Perl 5 project pages for setup.

Licensing and contribution

The README points contributors to the project's contribution guidelines in the .github folder. The code is licensed under the Apache License, Version 2.0, which the README links to the LICENSE file. That license choice is common for infrastructure projects and permits both internal and commercial use with the usual attribution and patent terms.

For someone evaluating Pingora, the Apache 2.0 license and the open contribution process mean the framework can be adopted without a separate commercial agreement. The documentation set, a quick start guide for building a load balancer and a user guide for servers and custom proxy logic, rounds out what the README points to before the technical docs. The API docs are available for all the crates.

Editorial conclusion

Pingora is Cloudflare Rust framework for building fast, reliable, programmable networked systems, proven by serving more than 40 million requests per second for several years in production. It proxies HTTP 1 and 2, gRPC, and websockets, supports several TLS backends with rustls experimental, and exposes customizable load balancing and failover. The workspace is a set of focused crates, Linux is the tier 1 platform, the current MSRV is 1.85, and the code is Apache 2.0 licensed. Teams choose it for memory safety over C or C++, raw performance, and a highly programmable API surface.

Frequently asked questions

Official sources

1. cloudflare/pingora on GitHub
2. Issues
3. License: Apache-2.0
4. README
5. Releases