Netstack.FM Podcast
A podcast about networking, Rust, and everything in between. Join us as we explore the stack: from protocols and packet flows to the people and projects building the modern internet, all through the lens of Rust. Featuring deep dives, crate spotlights, and expert interviews.
If you're into systems programming, networking theory, or the Rust ecosystem, you are in the right place.
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.
Episode 14 brings together Terts and Arya from NLnet Labs for a wide ranging conversation about the work that keeps the internet stable and trustworthy. The episode begins by exploring their personal journeys into systems programming and Rust, their involvement in community events such as Rust Week, and how they found their way into NLnet Labs. Their stories set the stage for understanding the mindset and mission behind an organization that supports some of the most widely deployed pieces of internet infrastructure.
The discussion moves into the history and purpose of NLnet Labs itself, including its long standing work on DNSSEC, authoritative and recursive DNS software, and the evolution of internet standards. Terts and Arya explain what makes DNS such a complex protocol to secure, why DNSSEC matters, and how projects like Cascade aim to offer a dependable, dedicated signer for operators who manage large or sensitive zones. We also highlight the operational realities that make DNS and DNSSEC both powerful and challenging.
In the final part of the episode, the focus shifts to BGP and Rotonda, along with the Roto scripting language that powers advanced filtering and high speed routing logic. Turns out Roto might well be the coolest Rust-specific scripting language available at the moment, with a bright future in front of it. The conversation dives into performance engineering, memory layout decisions, and the practical use of zero copy strategies in DNS and BGP software. The result is a clear and engaging look at how NLnet Labs approaches the design of resilient open source networking tools, and why careful engineering at every level continues to matter for the health of the global internet.
Learn more:
In this episode, Glen chats with Joseph Dye (Joe), founding engineer at Ping Proxies, about building massive proxy infrastructure in Rust. Joe shares how Ping evolved from Python and Squid to high-performance Rust proxies, tackling challenges like HTTP versions, TCP/IP fingerprinting, and user-space networking with DPDK.
On this episode of Netstack.fm recorded on November 10, 2025, Glen talks with Joseph Dye (Joe), the first engineer at Ping Proxies, about how a small student project grew into a top tier proxy provider. Joe shares his path from art school to Rust developer, the messy early days running Squid with a thin Python layer, and the decision to rebuild the stack in Rust for reliability, performance, and control. He explains what proxy companies actually sell and why at scale customers rely on many addresses to fetch the modern web safely and efficiently.
The conversation maps the product landscape at Ping Proxies, including data center proxies, ISP or static residential addresses, and true residential traffic via SDK partners. Joe describes their preference for simple transparent tunneling over HTTP CONNECT and for offering both HTTP and SOCKS5, with support for HTTP 1, HTTP 2, and HTTP 3. He discusses why HTTP 1 proved trickiest, how a sans IO approach helped, and how the team runs on bare metal with Kubernetes and Postgres while handling the practical realities of carriers, announcements, and leased address blocks.
Looking ahead, Joe dives into advanced work like TCP and IP fingerprint shaping with a user space stack, possible kernel bypass through DPDK, and emerging standards such as MASQUE with CONNECT UDP and CONNECT IP to make UDP and QUIC tunneling more accessible. He reflects on Rust as a force multiplier for a small team, the challenges of hiring, and how Ping Proxies competes by shipping new protocol capabilities quickly. It is a candid, technical, and very practical tour of what it takes to build and operate modern proxy infrastructure.
Learn more:
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.
In this episode, our guest is Ryan Goodfellow, Networking Engineer at Oxide Computer Company. We explore his work on Oxide’s rack-scale computer — a fully integrated hardware–software system built in Rust, from programmable switches and control planes to kernel modules and microcontrollers.
Ryan shares how his background in large-scale network testbeds and power grid simulation led him to help design Oxide’s networking stack, including the Maghemite routing system, OPTE packet engine, and Dendrite for programmable switching. We discuss P4 pipelines, X4C, and how Rust enables safer and more observable networking inside the Illumos-based platform.
The conversation dives into Delay-Driven Multipath (DDM), BGP, and modern routing inside Oxide’s racks, as well as the open-source ecosystem powering it — from Hubris (Rust OS for microcontrollers) and Falcon (virtual rack testbed) to developer tools like Dropshot, Progenitor, ISF, and RSF.
We also touch on the future of receiver-driven networking and internet research, inspired by The Tussle in Cyberspace and Named Data Networking. Ryan reflects on building robust systems with open hardware, Rust-based observability, and strong developer tooling across layers.
Learn more:
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.
In this episode, our guest is Max Inden, Staff Software Engineer at Mozilla, where he works on Firefox’s HTTP/3 and QUIC stack. We explore his work modernizing Firefox’s networking layer in Rust — from rewriting its UDP I/O path to improving performance across Linux, Windows, and Android through multi-packet system calls and advanced kernel integrations.
Max shares how he moved from Prometheus and peer-to-peer systems to shaping
the next generation of internet protocols at Mozilla. We discuss
HTTP/3 connection upgrades via Alt-Svc headers and
HTTPS DNS records, delve into the role of
stub resolvers and DNS over HTTPS (DoH).
We also touch on Happy Eyeballs v3, the evolution
of Firefox’s QUIC stack, and what it means to balance privacy, performance, and
interoperability across browsers and networks.
The conversation goes deeper into kernel-user space trade-offs, congestion control, and future protocol adoption — from WebTransport and MASQUE to multipath QUIC. Max reflects on the challenges of maintaining a multi-platform QUIC implementation, how community contributions shape Mozilla’s networking stack, and why open participation in the IETF remains one of the most inspiring parts of building the internet.
Learn more:
A conversation with Joshua Liebow-Feeser, the developer behind netstack3 and the creator of zerocopy, a crate that makes zero-cost memory manipulation effortless. Originally built for Fuchsia, zerocopy is now used by over 400 crates on crates.io, with nearly 300 million downloads.
We explore the origins of Fuchsia, the creation and purpose of zerocopy, how it works, and why you might want to use it. And of course, we get to know Joshua and his journey so far.
In this episode, our guest is Joshua, Software Engineer at Google and creator of ZeroCopy—the Rust crate enabling safe, zero-cost memory manipulation across hundreds of projects. We dive into Joshua’s journey from Cloudflare’s security team to Fuchsia’s networking stack, exploring how his background in formal methods and precise thinking shaped both Netstack3 and ZeroCopy’s design.
We discuss the origins of Netstack3 as a Rust-based
replacement for the Go-based Netstack2, the philosophy of encoding correctness
into Rust’s type system, and how the project evolved from a 20% side effort
into Fuchsia’s production networking stack. Joshua shares his perspective on
building reliable systems through mathematical precision, formal verification
with Kani, and the art of making complex systems feel elegant.
The conversation then turns to ZeroCopy: how it was born from
the need for safe, high-performance packet parsing, and how it leverages traits
like FromBytes and Unaligned to ensure memory safety
without runtime overhead. We unpack its derive macros, runtime guarantees, and
how ZeroCopy paved the way for Fuchsia’s packet parsing framework and the
upcoming Safe Transmute project in the Rust compiler.
We also touch on async design trade-offs in Netstack3, lessons in API design simplicity, and the — for some — surprising business case for correctness—like the fact that Netstack3 encountered only four bugs during its first 18 months of dogfooding. Joshua closes with reflections on abstraction design, delighting users, and Rust’s unique power to make ambitious system software possible.
Learn more:
A conversation with Lucio Franco, creator of Tonic as well as a prolific contributor and maintainer of tower, tokio and hyper(ium). In this episode we talk about Lucio's journey, an introduction to gRPC and Tonic, a gRPC implementation in Rust. We will also touch on the future of some of these ecosystems and where it all might be heading next.
In this episode, our guest is Lucio Franco, Senior Software Engineer, creator of Tonic and maintainer of the Tokio, Tower, and Hyper ecosystems. We explore the world of gRPC and Tonic—the Rust implementation of Google’s RPC framework built on top of HTTP/2 and Protobuf.
Lucio shares his journey from contributing to open source at Amazon
to creating Tonic, explaining how it evolved from the early days of
tower-grpc into today’s async-await-first library for distributed systems.
We discuss the technical motivations behind gRPC, its use of HTTP/2 streams,
metadata handling, and how Tonic integrates seamlessly with the Tokio stack.
The conversation also dives into Tower’s origins, its Finagle inspiration, and what it might take to bring Tower into the future. Lucio offers insights into Google’s ongoing collaboration with the Rust community to evolve Tonic further, enabling interoperability, better abstractions, and a stronger foundation for the next generation of networked Rust services.
Learn more:
In this episode our guest is Bruno Dal Bo Silva, Staff Software Engineer at Google. We dive into his path into networking and Rust, and the story behind netstack3, the Rust-based networking stack built for Google’s Fuchsia operating system. We cover its origins from the Go-based netstack, why Rust was chosen, and the challenges of implementing a full range of protocols — from TCP and UDP with their POSIX socket API to the many less-visible but essential pieces like ARP, ICMP, IPv6, DHCP, and more. We hope you brought a bowl as you're in for a juicy letter soup with this one. Bruno also shares insights on where he sees the future of netstack3 — including its potential beyond Google.
In this episode, our guest is Bruno Dal Bo Silva, Staff Software Engineer at Google. We dive into his journey from embedded systems and Bluetooth development to building netstack3—the Rust-based networking stack powering Google’s Fuchsia OS.
Bruno walks us through his early days in firmware and digital signal processing, his transition into networking at Google, and how he fell in love with Rust. We unpack the evolution from netstack1 to netstack2 (Go-based, from gVisor) and finally netstack3 in Rust, discussing its architectural benefits, memory determinism, and the microkernel design of Fuchsia.
We explore the life of a packet in Fuchsia, from Ethernet drivers to ARP,
IPv4/IPv6, TCP, and UDP. Bruno explains the challenges of implementing
POSIX compatibility in user space, the design of the async runtime, and
how Fuchsia’s fuchsia_async runtime compares to Tokio.
The conversation also touches on IPv6 auto-configuration (SLAAC),
DHCPv6, neighbor discovery, and how protocols like QUIC and Happy Eyeballs
fit into the evolving landscape of modern networking. Bruno shares his
perspective on what it would take to publish netstack3 on
crates.io and why broader community use could make the stack
even more robust.
Learn more:
A conversation with Dirkjan Ochtman, member of the Rustls core team and long-time open source contributor. We talk about Dirkjan’s journey through the FOSS ecosystem, the evolution of Rustls, and the many layers of meaning behind safety in the context of Rustls. We also touch on HickoryDNS and other projects along the way such as instant ACME.
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:
A conversation with Daniel Stenberg, creator and maintainer of
curl, one of the most widely used networking tools
on the internet. We talk about Daniel’s journey through decades
of protocol work, the story of curl, what keeps him
going, and how he balances open source with real life.
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:
A conversation with Carl Lerche, creator and maintainer of
Tokio, a widely used async runtime in Rust, and the
only runtime used and supported by rama™. We talk about Carl’s
journey into Rust, how and why he started Tokio, how the project
has evolved over the years, where it is headed next, and what to
expect from the upcoming Tokio Conference.
In this episode of Netstack.fm, Glen speaks with Carl Lerche, the creator and maintainer of the Tokio Runtime, about his journey into technology, the evolution of programming languages, and the impact of Rust on the software development landscape. They discuss the rise of async programming, the development of networking libraries, and the future of Rust in infrastructure.
Carl shares insights on the creation of the Bytes crate, the implications of io_uring, and his role at Amazon. The conversation also touches on the upcoming Tokio conference and the introduction of Toasty, a new query engine for Rust.
Learn more:
Glen interviews Delaney Gillilan, creator of DataStar, a framework for building real-time collaborative web applications. The conversation explores hypermedia, SSE, simplicity in programming, and how Datastar enables efficient real-time interactivity.
In this episode, Glen interviews Delaney, the creator of DataStar, a lightweight framework designed for building real-time collaborative web applications. Delaney shares his journey from being a 3D artist to a developer, emphasizing the importance of hypermedia and real-time visualization.
The conversation delves into the efficiency of DataStar, its use of Server-Sent Events (SSE), and the framework's potential for collaborative web experiences. Delaney also discusses the challenges of WebSockets and introduces future projects like DarkStar, aimed at enhancing networking capabilities.
In this conversation, Delaney discusses the intricacies of DataStar, a real-time system for handling large volumes of messages. He emphasizes the importance of simplicity in programming, the significance of measuring performance, and the role of abstraction in software development.
Delaney also explains the core functions of DataStar, including patch elements and signals, and how they facilitate real-time interactivity. The discussion touches on offline support, the growth of the DataStar community, and the non-profit model that supports its development. Delaney encourages developers to engage with the community and emphasizes the importance of building solutions to real problems.
Learn more about Datastar and Hypermedia:
A conversation with Chris Batterbee, co-founder of Metoro, about observability, eBPF, OpenTelemetry, and building a platform to simplify instrumentation in Kubernetes environments.
In this conversation, Chris Batterbee, co-founder of Metoro, discusses the importance of observability in modern software systems, particularly in Kubernetes environments. He explains how Metoro leverages eBPF technology to simplify observability by automatically instrumenting applications.
The discussion also covers the integration of OpenTelemetry, the challenges faced by developers in implementing observability, and the potential of AI in diagnosing issues. Chris shares insights from his experience with Y Combinator and the competitive landscape of observability tools, emphasizing the unique position of Metoro in the market.
Learn more about OpenTelemetry, eBPF and Metoro:
Glen interviews Sean McArthur, creator and maintainer of the Hyper ecosystem. They discuss Sean's journey in software engineering, the evolution of Rust and asynchronous programming, and the growth of Hyper from its inception at Mozilla to its current status in the web development landscape.
In this episode, Glen interviews Sean McArthur, the creator and maintainer of the Hyper ecosystem. They discuss Sean's journey in software engineering, the evolution of Rust and asynchronous programming, and the growth of Hyper from its inception at Mozilla to its current status in the web development landscape.
Sean shares insights on the creation of
hyper, hyper-util,
http, headers, the Warp
framework, and the challenges of integrating HTTP/3 and
QUIC. The conversation also touches on collaboration
with cURL, the FFI layer, and Sean's aspirations for the
future of Hyper and the broader ecosystem.
Learn more about Sean McArthur, Hyper and Warp:
In our debut we introduce the show and share what is to come. You will hear how Netstack.FM came to life and how the community can help shape its future.
In the inaugural episode of NetStack FM, hosts Elizabeth and Glen introduce themselves and the purpose of the podcast, which is to explore the intersection of protocols and people in the tech industry. Glen shares his personal journey into technology, discussing his background in software development, gaming, and networking.
The conversation highlights the challenges and learning experiences that shaped his careers, leading to the creation of rama™, a modular framework for building network services.
The episode concludes with a preview of upcoming guests and topics, emphasizing the podcast's goal to educate and engage listeners in the world of networking and Rust.
Here is a look at what is coming up on Netstack.FM. We usually release new episodes weekly. Dates and guests are subject to change. We keep this page updated as things evolve.
A focused conversation with Edward and Noah from Cloudflare about Pingora and the practical realities of building modern proxy infrastructure at scale. We dig into the architecture, protocol support and upgrade paths across HTTP versions, and the design choices that drive performance, reliability, and observability in production. We also touch on their personal journeys and what shaped their approach to systems and networking.
The discussion places Pingora in context with other open projects and frameworks, including Rama. We compare goals and trade offs, and explore where the approaches differ. Throughout the discussion we will also discuss other network technology at Cloudflare, a lot of which is also opensourced.
A conversation about the Sans IO approach to protocol design and how it shapes real world network implementations. We explore its application to HTTP, WebRTC, and DTLS, with a focus on how WebRTC and DTLS can benefit from decoupling logic from I/O.
Along the way, we discuss design boundaries, testing, and portability — and together with Martin, we reflect on how Sans IO fits into the broader philosophy of Rust, standing alongside ideas like the borrow checker and zero-cost abstractions as tools for building robust, elegant systems.
A conversation with early internet pioneer Larry Masinter about the invention of the URL, HTTP/1.1. Discussing also related protocols and RFCs. We will discuss most of his RFCs, some more brief than others, including but not limited to: the various URL and mime-type related RFCs, and of course... HTCPCP.
We will also discuss the origins and life of Larry, including his time as a principal scientist of Xerox Artificial Intelligence Systems and the work he has done at AT&T and Adobe.