netstack.fm

Edward Wang, a Cloudflare engineer specializing in the Rust-based Pingora proxy framework, joins the discussion alongside Noah. They dive into why Cloudflare transitioned from NGINX to Pingora, emphasizing its modular design and enhanced caching capabilities. Key topics include dynamic traffic handling, connection reuse strategies, and the power of gRPC support. Edward and Noah also explore performance optimizations, TLS backend configurations, and the benefits of using Tokio runtimes in modern networking. Their insights reveal the intricacies of developing high-performance proxies.

Episode 14 – Roto And Cascade with Terts and Arya from NLnet Labs.In this episode we have a conversation with Terts and Arya from NLnet Labs. Together we explore their paths into systems programming, the mission of NLnet Labs, and the critical internet infrastructure the organization maintains. The discussion spans DNSSEC, large scale DNS operations, Rotonda, and the Roto scripting language, with deep dives into performance engineering, zero copy design, and building resilient open source networking software. It is a technical episode that highlights the people and ideas behind essential internet protocols.Learn more:https://www.nlnetlabs.nl/ — NLnet Labs websitehttps://github.com/NLnetLabs/cascade — A friendly DNSSEC signing solutionhttps://indico.dns-oarc.net/event/55/contributions/1186 — slides of conference talk introducing Cascadehttps://github.com/NLnetLabs/rotonda — Modular, programmable BGP Enginehttps://github.com/NLnetLabs/roto — strongly-typed, compiled embedded scripting language for Rusthttps://www.youtube.com/watch?v=7xJEFPlfy7Y — EuroRust 2025 talk by Terts on Rotohttps://docs.rs/domain/latest/domain/new/base/wire/index.html — domain's zerocopy modulehttps://bal-e.org/blog/ — Blog from Aryahttps://2026.rustweek.org/ — RustWeek 2026 (with open CFP until EOY 2025)RamaIf you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.orgChapters00:00 Intro01:14 Backgrounds of Terts and Arya10:37 Overview of NLnet Labs17:43 Understanding DNSSEC25:29 The Role of Cascade in DNSSEC41:06 Understanding Roto and Rotonda45:55 The Evolution of Roto's Scripting Language49:34 Integration and Efficiency in Roto52:05 Real-World Applications of Roto01:00:36 The Importance of Data Structures in Performance01:06:34 Optimization Strategies for High Performance01:17:14 Zero-Copy Techniques in DNS Handling01:26:06 OutroNetstack.FMMore information: https://netstack.fm/#episode-14Join our Discord: https://discord.gg/29EetaSYCDReach out to us: hello@netstack.fmMusic for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj

Episode 13 – Inside Ping Proxies with Joseph Dye.In this episode of Netstack.fm, Glen from Plabayo talks with Joseph Dye (Joe), founding engineer at Ping Proxies, about building large-scale proxy infrastructure in Rust. Joe shares how he went from art student to programmer, joining Ping when it was a tiny startup running on Python and Squid. He explains how they rebuilt everything in Rust, creating performant HTTP and SOCKS5 proxies and managing massive IP networks for web scraping. The conversation covers the evolution of their stack, challenges with HTTP versions, TCP/IP fingerprinting, user-space networking with DPDK, and the adoption of MASQUE and HTTP/3. Joe also reflects on Rust’s safety benefits, being the only Rust engineer at Ping, and how the company stays competitive through technical innovation rather than size.Learn more:https://github.com/smoltcp-rs/smoltcp — A Rust-based user-space TCP/IP stackhttps://dpdk.org — The Data Plane Development Kit for high-performance packet processing and kernel bypasshttps://github.com/cloudflare/quiche — Cloudflare’s QUIC and HTTP/3 implementation, mentioned for MASQUE support w/ tokio supporthttps://github.com/tokio-rs/tokio — The asynchronous runtime used by Ping Proxies for concurrencyhttps://github.com/hyperium/h2 — Rust’s HTTP/2 library, referenced as part of Ping Proxies’ stackhttps://github.com/hyperium/h3 — Rust’s HTTP/3 library, used for advanced proxy tunnelinghttps://datatracker.ietf.org/doc/rfc9298 — Proxying UDP in HTTP (MASQUE)https://ipxo.com — Marketplace for leasing IP addresses, discussed in how Ping acquires IP rangeshttps://pawns.app/sdk/ — Example of SDK-based residential proxy provider referenced in the episodeRamaIf you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.orgChapters00:00 Intro00:41 Introduction to Proxies and Joe's background03:42 Understanding Pink Proxies and Their Offerings06:52 The Technical Journey: From Squid to Rust09:47 Proxy Types: Data Center vs. Residential12:42 Building a Proxy Infrastructure15:44 Challenges with HTTP Protocols18:39 The Importance of Customization in Proxy Development21:38 Team Dynamics and Future Growth29:32 Transitioning to Rust Development30:59 Understanding HTTP Protocols32:40 Exploring HTTP/2 and HTTP/334:05 The Future of Proxying with Mask36:14 Evaluating New Technologies for Proxies37:51 Developing for End User Devices39:49 Challenges in Network Stack Development41:15 Proxying Non-HTTP Traffic42:51 TCP/IP Fingerprinting Explained47:57 The Importance of TCP/IP Fingerprinting53:28 Performance Considerations in User Space TCP58:22 Competing in the Proxy Market01:00:05 Cancellation Safety in Rust Concurrency01:03:53 OutroNetstack.FMMore information: https://netstack.fm/#episode-13Join our Discord: https://discord.gg/29EetaSYCDReach out to us: hello@netstack.fmMusic for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj.

Episode 12 – Oxide Networking with Ryan Goodfellow.A conversation with Ryan Goodfellow about Rust networking at Oxide. We will explore the Oxide computer stack with a focus on network, including their fully integrated cloud computer, programmable networking with P4 and Dendrite, the Maghemite routing stack, and OPTE — a Rust-based packet engine running inside the kernel. Ryan also shares how his background in large-scale network testbeds led him to help design Oxide’s rack-scale system and its modern approach to routing, observability, and hardware–software co-design.Learn more:https://oxide.computer/ — Oxide Computer Companyhttps://github.com/oxidecomputer/opte — OPTE (Oxide Packet Transformation Engine)https://github.com/oxidecomputer/maghemite — Maghemite (Routing Stack)https://github.com/oxidecomputer/dendrite — Dendrite (P4 Switch Control)https://github.com/oxidecomputer/hubris — Hubris (Rust OS for Microcontrollers)https://github.com/oxidecomputer/falcon — Falcon (Virtual Rack Testbed)https://rfd.shared.oxide.computer/rfd/0347 — RFD 347 (Delay-Driven Multipath Routing (DDM))https://groups.csail.mit.edu/ana/Publications/PubPDFs/Tussle2002.pdf — The Tussle in Cyberspace (Paper)https://named-data.net/project/ndn/ — Named Data Networking Projecthttps://www.sigcomm.org/ — ACM SIGCOMM Conferencehttps://www.usenix.org/conference/nsdi26 — USENIX NSDI Symposiumhttps://oxide-and-friends.transistor.fm/episodes/the-frontend-of-the-computer — Oxide & Friends (Dropshot Episode)RamaIf you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.orgChapters00:00 Intro00:44 Meet Ryan Goodfellow06:23 Building Large-Scale Test Beds07:46 The future of the internet10:54 Overview of Oxide's Rack Scale Computer19:36 Exploring BGP and Routing Protocols26:02 The X4C Compiler and Its Origins39:43 Programming for Tofino and Observability45:10 Life of packets of an HTTP Web (Oxide Rack) server01:01:58 Exploring Maghemite: The Routing Stack01:12:45 Future Directions: Rust-Based Operating Systems01:19:28 Testing Strategies and the Falcon Framework01:27:25 OutroNetstack.FMMore information: https://netstack.fm/#episode-12Join our Discord: https://discord.gg/29EetaSYCDReach out to us: hello@netstack.fmMusic for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj.

Episode 11 – Modern networking in Firefox with Max Inden.A conversation with Max Inden, Staff Software Engineer at Mozilla, about modernizing Firefox’s networking stack in Rust. We cover his work on the QUIC and HTTP/3 stack — improving UDP I/O, congestion control, and overall performance — and why QUIC matters as a fast, encrypted, and evolvable transport for HTTP/3, WebTransport, and beyond.Learn more:https://max-inden.de/ — Personal website of Max Indenhttps://max-inden.de/post/fast-udp-io-in-firefox/ — Fast UDP I/O for Firefox in Rust — by Max Indenhttps://archive.fosdem.org/2025/schedule/event/fosdem-2025-4229-getaddrinfo-sucks-everything-else-is-much-worse/ — getaddrinfo sucks, everything else is much worse — Talk by Valentin Gosuhttps://github.com/mozilla/neqo — Mozilla Neqo (HTTP/3 and QUIC stack)https://datatracker.ietf.org/doc/html/rfc9000 — RFC 9000 – QUIC: A UDP-Based Multiplexed and Secure Transporthttps://datatracker.ietf.org/doc/html/rfc9114 — RFC 9114 – HTTP/3https://datatracker.ietf.org/doc/html/rfc9462 — RFC 9462 – Discovery of Designated Resolvershttps://www.rfc-editor.org/rfc/rfc8484.html — RFC 8484 – DNS Queries over HTTPS (DoH)https://datatracker.ietf.org/doc/draft-ietf-happy-happyeyeballs-v3/ — Happy Eyeballs Version 3 (Draft)https://github.com/microsoft/msquic — Microsoft MsQuichttps://developer.mozilla.org/en-US/docs/Web/API/WebTransport — WebTransport API documentationhttps://datatracker.ietf.org/wg/masque/about/ — MASQUE (Proxy) protocol introductionhttps://www.ietf.org/ — Internet Engineering Task Force (IETF)https://www.ietf.org/meeting/ — IETF MeetingsRamaIf you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.orgChapters00:00 Intro00:38 Introduction to Max Inden03:27 Max Inden's Journey to Mozilla06:32 The Role of IETF in Internet Design09:42 QUIC and HTTP/3 in Firefox12:27 Understanding HTTP/3 Upgrade Mechanisms15:15 Challenges with UDP and Firefox's Networking Stack18:15 Optimizing UDP I/O for Performance21:36 Cross-Platform Performance Considerations24:23 Network Drivers and Their Impact27:18 Exploring Happy Eyeballs and Connection Strategies30:07 WebTransport and Future of QUIC32:56 Contributions to Firefox and Open Source36:05 Happy Eyeballs and related56:15 Github Git Hosting57:24 Quic Usage within Firefox01:03:02 Closing Thoughts and call to Action01:06:44 OutroNetstack.FMMore information: https://netstack.fm/#episode-11Join our Discord: https://discord.gg/29EetaSYCDReach out to us: hello@netstack.fmMusic for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj.

Joshua Liebow-Feeser, a software engineer at Google and the visionary behind the zerocopy Rust crate, shares his journey from software development to creating high-performance systems. He dives into the origins of Fuchsia, the benefits of zero-copy memory manipulation, and how Rust enhances safety in networking stacks. Joshua elaborates on the design philosophy of NetStack 3, emphasizing type safety and correctness. He also discusses the challenges of variable-length data and the importance of formal verification in building robust software.

Lucio Franco, a senior software engineer and creator of Tonic, dives into the world of async networking in Rust. He discusses the origins of gRPC and its Rust implementation, addressing its advantages over REST and the significance of HTTP/2 for efficiency. Lucio shares insights on the design challenges faced while developing Tonic, the open-source collaboration with Google, and how Tonic integrates with various runtimes. He also highlights practical tips for getting started with Tonic, making this a must-listen for Rust enthusiasts!

Bruno Dal Bo Silva, a Staff Software Engineer at Google, discusses his journey from Brazil to systems programming, focusing on networking and Rust. He dives into the development of Netstack3 for Fuchsia, highlighting the shift from Go to Rust and its impact on performance. Bruno explains the intricacies of protocols like DHCP and IPv6 SLAAC, sharing insights on memory management and zero-copy techniques. He also explores the potential of Netstack3 beyond Google, emphasizing the benefits of open-sourcing for robust contributions to the connectivity landscape.

Episode 7 – Rustls with Dirkjan Ochtman.In this episode, we go through Dirkjan's extensive experience in software development, particularly focusing on Rust, TLS, and QUIC protocols.We explore Dirkjan his journey working on QUIC implementations to his contributions to Rust TLS and Hickory DNS. The conversation also delves into the ACME protocol and the Instant Domain Search project.Dirkjan shares insights on the future of Rustls and the importance of community support in open-source projects.Learn more:https://dirkjan.ochtman.nl/https://github.com/rustls/rustlsrustls 0.24 tracking issue: https://github.com/rustls/rustls/issues/2400HickoryDNS Let's Encrypt tracking issue: https://github.com/hickory-dns/hickory-dns/issues/2725https://github.com/djc/instant-acmehttps://instantdomainsearch.com/RamaIf you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.orgChapters00:00 Intro00:44 Introduction to Dirkjan Ochtman02:02 Dirkjan's Rustls contributor origins04:18 Quic implications on Rustls13:35 Exploring the H3 Protocol and Its Challenges16:47 Contributions to Hickory DNS22:59 instant ACME28:43 R2D2 — Connection Pooling32:13 the EPP Protocol34:40 Insights from Working with Domain Registrars35:36 Rustls and Safety50:31 The Future of Rust TLS and Its Ecosystem54:50 OutroNetstack.FMMore information: https://netstack.fm/#episode-7Join our Discord: https://discord.gg/29EetaSYCDReach out to us: hello@netstack.fmMusic for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj.

Episode 6 – Curl with Daniel Stenberg.In this episode of netstack.fm, Glen speaks with Daniel Stenberg, the creator and maintainer of Curl, one of the most widely used networking tools on the internet. They discuss Daniel's journey into programming and networking, the evolution of Curl from a simple tool to a comprehensive solution supporting multiple protocols, and the challenges of maintaining such a large open-source project. Daniel shares insights on the importance of community involvement, the complexities of debugging across various platforms, and his reflections on a 30-year journey with Curl. The conversation highlights the significance of open-source contributions and the future of Curl as a project.Learn more:https://curl.se/https://daniel.haxx.se/https://daniel.haxx.se/blog/https://github.com/curl/curlRamaIf you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.orgChapters00:00 Intro00:36 Introduction to Curl and Daniel Stenberg05:20 Understanding Protocols and Specifications08:10 The Birth of Curl: From IRC Bot to Networking Tool12:46 Curl's Evolution and Protocol Support15:58 The Decision to Focus on Client-Side Development17:40 Current Protocol Support in Curl22:17 Managing Complexity in Curl's Codebase25:33 The Choice of C as the Programming Language28:33 Continuous Development and Community Engagement30:16 Balancing Work, Family, and Open Source Contributions36:37 Transitioning to Full-Time Work on Curl41:38 The Challenge of Funding Open Source Projects46:44 Exploring Commercial Opportunities with Curl49:53 Ensuring Curl's Longevity and Succession Planning51:58 Tackling Technical Challenges in Open Source Development57:05 Reflecting on a 30-Year Journey with Curl01:00:07 OutroNetstack.FMMore information: https://netstack.fm/#episode-6Join our Discord: https://discord.gg/29EetaSYCDReach out to us: hello@netstack.fmMusic for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj.