netstack.fm

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.

Episode 10 – zerocopy with Joshua Liebow-Feeser.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.Learn more:https://model-checking.github.io/kani/ — Kani verifierhttps://github.com/rust-lang/rust/issues/99571 — Safe Transmute tracking issuehttps://github.com/rust-lang/unsafe-code-guidelines — Unsafe Code Guidelines WGhttps://docs.rs/zerocopy/latest/zerocopy/ — ZeroCopy documentationhttps://docs.rs/zerocopy-derive/latest/zerocopy_derive/ — ZeroCopy derive macroshttps://fuchsia.dev/fuchsia-src/get-started/learn/intro/architecture — Fuchsia networking architecturehttps://docs.kernel.org/networking/scaling.html — Scaling in the Linux Networking Stackhttps://www.youtube.com/watch?v=rFejpH_tAHM — dotGo 2015 - Rob Pike - Simplicity is ComplicatedRamaIf you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.orgChapters00:00 Intro00:39 Introduction to Joshua Liebow-Feeser01:34 Joshua's Journey into Software Development11:41 The Origins of Netstack 317:21 The Philosophy Behind Netstack 323:03 The Role of Rust in Networking42:57 The Concept and Development of ZeroCopy53:10 Understanding Zero Copy and Its Constraints55:11 Exploring Memory Management in Networking59:23 Challenges with Variable Length Data Formats01:04:20 Async Programming and Its Implications01:11:13 Performance Considerations in Networking01:16:50 Ambition in Software Design and API Simplicity01:32:13 The Future of Networking and Rust's Role01:42:42 OutroNetstack.FMMore information: https://netstack.fm/#episode-10Join 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 9 – gRPC with Lucio Franco.A deep dive into the world of asynchronous networking in Rust with Lucio Franco, maintainer of Tonic, Tower, Tokio, and Hyper. We explore the origins and design of gRPC and its Rust implementation, Tonic—how it came to be, what problems it solves, and why it matters. Along the way, Lucio shares insights into open source collaboration, Google’s work on gRPC for Rust, and what the future might hold for the broader async Rust ecosystem.Learn more:https://github.com/hyperium/tonic — Tonic on GitHubhttps://github.com/tokio-rs/tokio — Tokio runtimehttps://github.com/tower-rs/tower — Tower libraryhttps://github.com/tower-rs/tower-grpc — Archived tower-grpc projecthttps://grpc.io/ — gRPC official sitehttps://github.com/hyperium/tonic/blob/master/examples/helloworld-tutorial.md — Tonic "hello world" tutorialhttps://docs.rs/tonic/latest/tonic/ — Tonic technical documentationhttps://twitter.github.io/finagle/ — Finaglehttps://github.com/linkerd/linkerd2 — linkerd2RamaIf you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.orgChapters00:00 Intro00:45 Introduction to Lucio06:50 Lucio's Journey in Rust and Open Source14:45 Future of tower29:48 Exploring gRPC: Concepts and Features36:33 gRPC vs HTTP: A Comparative Analysis43:38 The Role of Proxies in gRPC Communication54:12 Integrating Tonic with Other Stacks59:15 Collaboration with Google on Tonic01:07:03 Getting Started with Tonic and gRPC01:09:48 Tonic Ecosystem: Recommended Crates01:14:19 The Naming of Tonic01:16:38 gRPC Web: Bridging the Browser Gap01:23:16 Proxying gRPC Data: Considerations and Challenges01:27:08 OutroNetstack.FMMore information: https://netstack.fm/#episode-9Join 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 8 – Fuchsia's Netstack3 with Bruno Dal Bo Silva.In this episode our guest is Bruno Dal Bo Silva, Staff Software Engineer at Google. We will 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 or a juicy letter soup with this one. Bruno also shares insights on where he sees the future of netstack3 — including its potential beyond Google.Learn more:https://fuchsia.dev/netstack3 source code: https://fuchsia.googlesource.com/fuchsia/+/refs/heads/master/src/connectivity/network/netstack3/netstack3 publishing tracking bug: https://fxbug.dev/448156020Fast UDP I/O for Firefox in Rust: https://max-inden.de/post/fast-udp-io-in-firefoxRFC 2462 - SLAAC: https://www.rfc-editor.org/rfc/rfc2462smoltcp (Rust TCP/IP stack for embedded): https://github.com/m-labs/smoltcpRamaIf you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.orgChapters00:00 Intro00:42 Introduction to Bruno and his Journey04:37 Bruno's Engineering Background and Its Impact06:56 Exploring Fuchsia: Overview and Architecture10:08 Transitioning to NetStack 3: The Rust Revolution17:35 Diving into Networking Protocols: Life of a Packet24:45 Understanding ARP and Ethernet Protocols28:00 Dynamic Host Configuration Protocol (DHCP) Explained34:41 The Future of Networking: IPv6 and Happy Eyeballs40:52 QUIC Protocol: User Space vs Kernel Space46:53 More about netstack3 and unsafe code usage55:22 Async usage in Netstack301:00:36 Comparing netstack3 with smolltcp01:04:50 Running your own TCP stack on the linux platform01:06:25 Roadmap to get fuchsia on crates.io01:11:37 Closing Thoughts and Future Directions01:15:32 OutroNetstack.FMMore information: https://netstack.fm/#episode-8Join 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 7 – Rustls with Dirkjan OchtmanIn 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.

Episode 5 – Tokio with Carl Lerche.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:https://tokio.rs/https://www.tokioconf.com/https://github.com/carllercheRamaIf you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.orgChapters00:00 Intro00:45 Origins of Carl04:01 Parallel between DotCom Bubble and current AI wave05:52 Origins of Carl... Continued09:12 Carl discovers Rust in 201413:40 Creation of mio17:39 mio, tokio and futures19:15 Powers of Rust25:57 io_uring26:12 The Evolution of IO-URing and Its Practicality29:40 Carl's job at Amazon and Tokio30:51 Maintaining Tokio today and beyond32:30 Toasty38:58 AI in Software Development: A Tool for Productivity49:20 First Tokio Conference53:10 Final words55:17 OutroNetstack.FMMore information: https://netstack.fm/#episode-4Join our Discord: https://discord.gg/VN77rKHRReach 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 4 – Datastar and Hypermedia.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. Overall, the episode highlights the transformative potential of DataStar in modern web development. 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:https://data-star.dev/https://data-star.dev/reference/datastar_prohttps://hypermedia.systems/RamaIf you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.orgChapters00:00 Intro00:42 Delaney and his background02:39 The Evolution of Hypermedia and Real-Time Systems06:27 SSE and Compression15:33 The Social Web23:01 Why use datastar?29:42 Web Transport and Darkstar33:55 DataStar and Future Directions46:04 Understanding Abstraction in Programming50:19 DataStar: Key Functions and Concepts53:27 Signals in DataStar: When to Use Them57:25 Front-End Validation and User Experience59:27 Offline Support and Web Applications01:02:56 The Growth of DataStar and Community Engagement01:07:09 The Challenges of Web Development01:09:26 AI and Its Role in Development01:13:22 DataStar and WebTransport: Future Directions01:16:33 Dynamic Content and DataStar's Use Cases01:18:35 Funding and Sustainability of Open Source Projects01:31:02 OutroNetstack.FMMore information: https://netstack.fm/#episode-4Join our Discord: https://discord.gg/VN77rKHRReach 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 3 – OpenTelemetry, eBPF and Metoro.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:https://opentelemetry.io/https://ebpf.io/https://metoro.io/metoro demo: https://demo.us-east.metoro.io/guardian?startEnd=&service=OpenTelemetry metric examplar: https://opentelemetry.io/docs/specs/otel/metrics/data-model/#exemplarsRamaIf you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.orgChapters00:00 Intro00:41 Chris Batterbee his background02:27 eBPF intro in context of Metoro04:20 eBPF + OpenTelemetry06:37 Opentelemetry Experience14:19 WASM16:10 eBPF and Windows16:59 Y Combinator Experience23:52 OpenTelemetry standard25:50 Platform is king26:53 eBPF accessibility28:30 Future of Prometheus29:41 Metoro and LLMs32:14 Replacing Sentry and the like33:46 Profiling35:39 Metoro Subscription Models36:37 Final words38:57 OutroNetstack.FMMore information: https://netstack.fm/#episode-3Join our Discord: https://discord.gg/VN77rKHRReach 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 2 – Hyper with Sean McArthur.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:https://seanmonstar.com/https://seanmonstar.com/sponsor/https://hyper.rs/https://seanmonstar.com/blog/async-hyper/https://github.com/hyperium/hyperhttps://github.com/seanmonstar/warphttps://seanmonstar.com/blog/warp/RamaIf you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.orgChapters00:00 Intro00:45 Introduction to Sean and the Hyper Ecosystem01:48 Sean's entrance into Rust06:17 The Impact of Mozilla on Sean's Career07:54 The Development of Hyper and Its Challenges13:20 Realizing Hyper's Long-Term Potential15:32 The Creation of hyper-util and Its purpose17:32 http and headers crates22:40 Navigating API Design Challenges22:47 The Philosophy Behind Warp Framework26:43 Integrating HTTP/2 and HTTP/3 Support28:54 The Evolution of the Requests Library30:17 Commercial Aspects of Hyper31:31 The Complexities of HTTP/3 Integration34:35 Reflections on the cURL and Hyper Collaboration38:50 Maintaining Open Source Independence40:16 Future Aspirations for Hyper41:23 Encouraging Community Engagement in Open Source42:28 Final words43:57 OutroNetstack.FMMore information: https://netstack.fm/#episode-2Join our Discord: https://discord.gg/VN77rKHRReach out to us: hello@netstack.fmMusic for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj.

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.More information: https://netstack.fm/#episode-1Join our Discord: https://discord.gg/VN77rKHRReach out to us: hello@netstack.fmMusic for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj.