netstack.fm

Season 2 · Episode 1 – Small Crates Behind Big Rust Systems.

In this first episode of season two of Netstack.fm, Glen talks with Jon Gjengset, principal engineer at Helsing, author of Rust for Rustaceans, and one of the best known teachers in the Rust community. They explore the craft of building small, sharply scoped crates, from arccstr, left-right, and HdrHistogram to atone, and discuss Fantoccini and the WebDriver protocol, maintaining open source sustainably, and why the Rust project should not bless crates.

Learn more:

• https://www.youtube.com/@jonhoo — Jon's streams and Decrusting videos
• https://rust-for-rustaceans.com/ — Rust for Rustaceans
• https://github.com/jonhoo/rust-imap — imap
• https://github.com/jonhoo/arccstr — arccstr
• https://github.com/vorner/arc-swap — arc-swap
• https://github.com/jonhoo/left-right — left-right
• https://www.youtube.com/watch?v=eLNAMEoKAAc — Jon's walkthrough of the left-right algorithm
• https://github.com/jonhoo/fantoccini — Fantoccini
• https://github.com/helsing-ai/dson — DSON, a delta-state CRDT
• https://github.com/helsing-ai/sguaba — Sguaba, type-safe coordinate transforms
• https://github.com/HdrHistogram/HdrHistogram_rust — HdrHistogram
• https://github.com/jonhoo/inferno — Inferno
• https://github.com/jonhoo/atone — atone

Rama

If you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.org

Chapters

• 00:00 Intro
• 01:16 Introduction to the Podcast and Guest
• 02:02 Meet Jon Gjengset and His Career Path
• 05:00 Embracing Challenges and Learning Opportunities
• 06:10 From Using Rust in His PhD to Teaching It
• 08:35 Decrusting Crates and Learning in Public
• 13:17 Building High-Performance Crates
• 15:33 Scoping Crates for Completeness
• 19:26 Handing Off the IMAP Crate
• 25:17 Compact Shared Strings: arccstr
• 27:48 Comparing Concurrency Primitives: arc-swap vs. left-right
• 30:39 Understanding Data Structures and Performance Trade-offs
• 33:39 Sustainable Open Source Maintenance
• 37:55 Reader-Writer Lock Contention
• 41:18 Low-Level Programming, With or Without Rust
• 45:42 Navigating Unfamiliar Codebases
• 49:24 Exploring the WebDriver Protocol and Fantoccini
• 58:32 Why Not Be a Researcher for Hire?
• 01:02:50 Engineering at Helsing: CRDTs and Type-Safe Transforms
• 01:05:34 Efficient Metrics with HdrHistogram
• 01:10:54 Porting FlameGraph from Perl to Rust: Inferno
• 01:13:49 Officially Endorsed or Independently Maintained Crates?
• 01:20:33 Avoiding Resize Latency Spikes: atone
• 01:23:13 Outro

Netstack.FM

• More information: https://netstack.fm/episodes/small-crates-behind-big-rust-systems
• Join our Discord: https://discord.gg/29EetaSYCD
• Reach out to us: [email protected]

Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj

In this Protocol Shorts episode of Netstack.fm, Glen talks with Brecht Stamper about Rama, the modular Rust framework for building clients, servers, proxies, and other network systems. Brecht shares how he came to understand Rama’s core idea that everything is a service, and why that simple input to output contract makes it easier to compose complex stacks without constantly inventing new traits or glue code.

They also discuss how Rama helps with testing, including gRPC client and server logic without spinning up real HTTP or TCP infrastructure. The conversation then moves into practical production lessons, such as gRPC latency caused by TCP_NODELAY, the role of OpenTelemetry and logging, and how Rama can provide better abstractions while still allowing low level control.

Later in the episode, Glen and Brecht explore Rama’s evolving extension system, including the move toward append only extensions, clearer separation between request and connection state, and support for complex scenarios such as HTTP/2 streams and protocol upgrades.

They close with thoughts on where Rama is heading next, including HTTP/3, QUIC, better developer tooling, performance work, and making more hard won network fixes available to everyone through the framework.

Learn more

• https://ramaproxy.org/ — Rama homepage: modular Rust framework for proxies, clients, servers, inspection, tunneling, and network diagnostics.
• https://ramaproxy.org/book/ — Rama book: broader introduction to Rama and its approach to fine grained programmable control over network stacks.
• https://ramaproxy.org/docs/rama/index.html — Rama API documentation: generated Rust docs for the main Rama crate.
• https://github.com/plabayo/rama — Rama source code on GitHub.

• 00:00 Intro
• 00:48 Introduction to Rama and Brecht's Role
• 02:46 Understanding Services in Rama
• 08:22 Testing and Mocking in Rama
• 10:23 gRPC and TCP Configuration Issues
• 15:35 Evolution of Extensions in Rama
• 24:58 Building with Rama and Rama's Horizon
• 31:52 Outro

• More information: https://netstack.fm/#episode-38
• Join our Discord: https://discord.gg/29EetaSYCD
• Reach out to us: [email protected]
  

Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj

episode 37: dial9: from black box to insight in Tokio.

In this episode of Netstack.fm, Glen talks with Jess Izen and Russell Cohen from Amazon about Dial9, a new tool for understanding what’s happening inside Rust and Tokio applications. They explain how it captures events from different layers of your system and puts them into a single timeline, making it much easier to debug tricky performance issues and unexpected behavior.

They also share how Dial9 came out of real debugging challenges at Amazon, where engineers often had to rely on complex, low level tools. The goal with Dial9 is to make those kinds of insights more accessible, so developers can diagnose problems faster and with less guesswork, while the tool continues to evolve with new features and improvements.

Learn more:

• https://www.youtube.com/watch?v=yTlThfOcslM — TokioConf 2026 - Lightning Talk: dial9: WTF is Tokio actually doing? by Russell Cohen

• https://tokio.rs/blog/2026-03-18-dial9 — Introducing dial9: a flight recorder for Tokio
• https://github.com/dial9-rs/dial9-tokio-telemetry — source code (Tokio Telemetry you can run in production)
• https://github.com/dial9-rs/dial9-tokio-telemetry/blob/main/dial9-trace-format/SPEC.md — trace format spec
• https://www.youtube.com/watch?v=kr0RYMu57kU — demo walkthrough (slightly outdated)
• https://github.com/dial9-rs/dial9-tokio-telemetry/blob/main/dial9-tokio-telemetry/examples/production_use.rs — example

Rama

If you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.org

Chapters

• 00:00 Intro
• 02:01 Meet Russell and Jess
• 05:27 The Mission of the Rust Team at Amazon
• 11:47 Integration with OpenTelemetry and Tracing
• 13:49 The Evolution of Dial 9
• 17:17 Comparing Dial 9 with Existing Tools
• 20:07 Continue exploring history and development and UX of Dial9
• 33:47 Building Self-Serve Solutions
• 36:22 perf sched
• 38:30 Task Dumps
• 41:17 Dial 9: almost a free lunch
• 43:00 Cross-Platform Considerations for Dial 9
• 46:20 Future Features and Improvements for Dial 9
• 50:20 Dial 9 usage today
• 54:31 Considerations before using Dial 9
• 01:03:05 Getting Started with Dial 9
• 01:05:30 Outro

Netstack.FM

More information: https://netstack.fm/#episode-37

Join our Discord: https://discord.gg/29EetaSYCD

Reach out to us: [email protected]

Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj

Episode 36 – Protocol Shorts: WireGuard

In this Protocol Shorts episode of netstack.fm, we explore WireGuard, a modern and lightweight VPN protocol. Glen explains what makes it different from traditional VPNs and why its simplicity and security model are gaining attention among developers.

The episode also highlights real world use cases and why VPNs like WireGuard remain essential for securely accessing private resources.

Learn more:

• https://www.wireguard.com/ — official website of WireGuard
• https://www.wireguard.com/papers/wireguard.pdf — WireGuard whitepaper
• https://www.youtube.com/watch?v=OipNNLHLphw —
  Black Hat USA 2018 - WireGuard Next Generation Secure Network Tunnel

Rama

If you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.org

Chapters

• 00:00 Intro
• 00:18 Introduction to WireGuard
• 01:41 WireGuard Properties
• 03:24 Why WireGuard?
• 07:43 Current Use Cases and Adoption of WireGuard
• 11:42 Get started with WireGuard
• 14:37 Final Words
• 15:17 Outro

Netstack.FM

• More information: https://netstack.fm/#episode-36
• Join our Discord: https://discord.gg/29EetaSYCD
• Reach out to us: [email protected]

Music for this episode was composed by Dj Mailbox.
Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj.

Remaster of: Season 1 · Episode 3 — OpenTelemetry, eBPF, and Metoro

In this remastered episode, 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/#exemplars

Rama

If you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.org

Chapters

• 00:00 Intro
• 00:34 Into to Chris Battarbee
• 02:36 Understanding eBPF and Its Role in Observability
• 10:13 Integrating OpenTelemetry with eBPF
• 15:05 Challenges and Experiences with OpenTelemetry
• 22:28 Future of eBPF and OpenTelemetry in Different Environments
• 27:53 YCombinator Experience
• 29:31 Insights from Y Combinator Experience
• 32:31 Networking and Community in Y Combinator
• 34:43 Raising Funds Post-Y Combinator
• 35:39 Post-Y Combinator Relationship with YC
• 36:27 OpenTelemetry Pain Points
• 38:31 The Future of OpenTelemetry and Standards
• 39:47 Competition with Major Cloud Providers
• 41:40 Understanding eBPF and Its Challenges
• 43:24 Prometheus vs. OpenTelemetry
• 44:40 AI Integration in Telemetry
• 45:36 Metoro
• 49:03 Profiling
• 51:43 Metoro Payment Models
• 53:57 Customer Engagement and Support
• 55:09 Outro

Netstack.FM

• More information: https://netstack.fm/#episode-35
• Join our Discord: https://discord.gg/29EetaSYCD
• Reach out to us: [email protected]

Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj.

Remaster of: Season 1 · Episode 5 — Tokio with Carle Lerche

Episode 34 — Tokio with Carl Lerche.

In this remastered episode, 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/carllerche

Rama

If you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.org

Chapters

• 00:00 Intro
• 01:26 Introduction to Carl and His Journey in Tech
• 16:30 How Carl got into Rust
• 21:18 How Mio/Tokio begun
• 47:15 The Evolution of IO-URing and Its Practicality
• 53:11 Amazon's Adoption of Rust and Tokyo
• 55:06 Transitioning Leadership in the Tokyo Project
• 57:15 Toasty
• 01:08:55 AI in Software Development: A Tool for Productivity
• 01:25:53 First Tokio Conference
• 01:34:28 Outro

Netstack.FM

• More information: https://netstack.fm/#episode-34
• Join our Discord: https://discord.gg/29EetaSYCD
• Reach out to us: [email protected]

Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj.

Episode 33 – Protocol Shorts: TLS Encrypted Client Hello.

This episode explores TLS Encrypted Client Hello (ECH) and how it improves privacy on the internet by hiding sensitive metadata that was previously exposed during the TLS handshake. While traditional TLS encrypts the actual data exchanged between client and server, key details like the Server Name Indication (SNI), which reveals the website you are visiting, remained visible to intermediaries such as ISPs or network middleboxes.

Glen explains how ECH addresses this gap by encrypting most of the Client Hello message using keys obtained via secure DNS, preventing third parties from easily identifying user activity. The discussion also covers real-world implications, including the impact on network infrastructure that relies on traffic inspection and the role of cloud providers in TLS termination.

Learn more:

• https://datatracker.ietf.org/doc/rfc9849/ — TLS Encrypted Client Hello
• https://blog.cloudflare.com/encrypted-client-hello/ — Practical explanation of ECH and deployment
• https://developer.mozilla.org/en-US/docs/Web/Security/Transport_Layer_Security — TLS fundamentals and handshake overview
• https://www.cloudflare.com/learning/ssl/what-happens-in-a-tls-handshake/ — another TLS handshake overview
• https://tls12.xargs.org/ — a tls 1.2 handshake, explained byte by byte
• https://tls13.xargs.org/ — a tls 1.3 handshake, explained byte by byte
• https://www.rfc-editor.org/rfc/rfc8446 — TLS 1.3 specification and handshake details
• https://blog.mozilla.org/security/2021/01/07/encrypted-client-hello-the-future-of-esni-in-firefox/ — Firefox perspective on ECH adoption
• https://blog.mozilla.org/security/2021/01/07/encrypted-client-hello-the-future-of-esni-in-firefox/ — Firefox perspective on ECH adoption
• https://samueloph.dev/blog/i-use-curl-with-ech-btw-in-debian/ — blog article about adding ECH into curl
• https://www.rfc-editor.org/rfc/rfc9460 — a DNS record type that publishes connection parameters for a service
• https://fosdem.org/2026/schedule/event/CKANPK-programmable_networking_with_rama/ — FOSDEM 2026 talk about Rama
  

Rama

If you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.org

Chapters

• 00:00 Intro
• 00:27 Understanding the TLS Handshake Process
• 06:54 Understanding Middle Boxes and Network Behavior
• 08:33 The Privacy Gap in Network Traffic
• 14:08 Current Usage and Future of ECH
• 18:00 Consequences of ECH for Existing Infrastructures
• 24:19 Future of ECH: Privacy vs. Trust
• 26:32 Outro
  

Netstack.FM

More information: https://netstack.fm/#episode-33

Join our Discord: https://discord.gg/29EetaSYCD

Reach out to us: [email protected]

Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj.

Remaster of: Season 1 · Episode 4 — Datastar and Hypermedia

Episode 32 – Datastar and Hypermedia.

In this remastered 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_pro
• https://hypermedia.systems/

Rama

If you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.org

Chapters

• 00:00 Intro
• 01:12 Delaney and his background
• 03:09 The Evolution of Hypermedia and Real-Time Systems
• 06:58 SSE and Compression
• 16:04 The Social Web
• 23:32 Why use datastar?
• 30:12 Web Transport and Darkstar
• 34:26 Final Thoughts on DataStar and Future Directions
• 46:35 Understanding Abstraction in Programming
• 49:18 Event Sourcing and Efficiency in Systems
• 50:50 DataStar: Key Functions and Concepts
• 53:58 Signals in DataStar: When to Use Them
• 57:56 Front-End Validation and User Experience
• 59:58 Offline Support and Web Applications
• 01:03:26 The Growth of DataStar and Community Engagement
• 01:07:39 The Challenges of Web Development
• 01:09:56 AI and Its Role in Development
• 01:13:52 DataStar and WebTransport: Future Directions
• 01:17:03 Dynamic Content and DataStar's Use Cases
• 01:19:06 Funding and Sustainability of Open Source Projects
• 01:31:32 Outro

Netstack.FM

More information: https://netstack.fm/#episode-32

Join our Discord: https://discord.gg/29EetaSYCD

Reach out to us: [email protected]

Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj.

episode 31 — Protocol Shorts: MITM Proxies and Transparent L4 Interception.

In this second "Protocol Shorts" episode, we look at man-in-the-middle proxies from the transport layer up. The episode explains how HTTP proxies, HTTP CONNECT, and SOCKS5 differ, why they all assume a proxy-aware client, and what changes when a transparent layer 4 proxy is inserted by the operating system instead.

From there, we dig into protocol detection from the first bytes on the wire and into the BridgeIo abstraction in Rama: a way to relay and inspect stacked handshakes incrementally instead of terminating every protocol upfront.

Learn more:

• https://netstack.fm/#episode-23 — Protocol Shorts: HTTP as an Application Bus
• https://ramaproxy.org/book/proxies/intro.html — Intro to proxies in the Ramabook
• https://ramaproxy.org/book/proxies/http.html — HTTP(S) proxies in the Rama boo
• https://ramaproxy.org/book/proxies/socks5.html — SOCKS5 proxies in the Rama book
• https://ramaproxy.org/book/proxies/mitm.html — MITM proxies in the Rama book</></li>
• https://ramaproxy.org/book/proxies/protocol_inspection.html — Protocolinspection in the Rama book
• https://ramaproxy.org/book/proxies/operate/transparent.html — Operating transparent proxies with Rama
• https://github.com/plabayo/rama/tree/main/ffi/apple/examples/transparent_proxy — MacOS Transparent Proxy (Rama) example

Rama

If you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.org

Chapters

• 00:00 Intro
• 01:00 Understanding Proxies: The Basics
• 01:18 Diving Deeper into Proxy Types
• 04:16 Layer 4 Proxies: A New Approach
• 05:23 Challenges of Transparent Proxies
• 07:53 Bridging Conversations: A New Insight
• 09:53 Example: HTTPS request within a SOCKS5 tunnel
• 13:41 Layer 4 Proxies and Protocol Reconstruction
• 15:15 Outro

Netstack.FM

• More information: https://netstack.fm/#episode-31
• Join our Discord: https://discord.gg/29EetaSYCD
• Reach out to us: [email protected]

Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj

episode 30: uReq with Martin Algesten.

In this episode, we take a deep dive into uReq: why it was created, its history and origin, a high level overview, and explore in depth its protocols and implementation details.

Learn more:

• https://github.com/algesten/ureq — A simple, safe HTTP client
• https://github.com/algesten/ureq/blob/main/src/run.rs - example on how uReq and Sans IO come together
• https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Expect — Expect 100 Continue
• https://github.com/algesten — Github profile of Martin Algesten
• https://github.com/algesten/str0m — A Sans I/O WebRTC implementation in Rust
• https://netstack.fm/#episode-16 — WebRTC and Sans IO with Martin Algesten

Rama

If you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.org

Chapters

• 00:00 Intro
• 00:58 Get to know Martin
• 06:46 Evolution of uReq: From Simplicity to Compliance
• 20:35 Sans IO
• 26:58 uReq prior to Sans IO
• 30:57 Practical Examples: Handling Complex Protocols
• 50:54 Sans IO in Str0m and uReq
• 55:01 Handling Proxies and DNS Resolution
• 01:02:51 The Future of uReq and uReq Proto
• 01:07:06 Sans IO and h2
• 01:09:00 Final Thoughts and Community Feedback
• 01:20:09 Outro

Netstack.FM

More information: https://netstack.fm/#episode-30

Join our Discord: https://discord.gg/29EetaSYCD

Reach out to us: [email protected]

Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj

Remaster of: Season 1 · Episode 2 — Hyper with Sean McArthur

In this remastered 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/hyper
• https://github.com/seanmonstar/warp
• https://seanmonstar.com/blog/warp/

Rama

If you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.org

Chapters

• 00:00 Episode remaster notes
• 00:37 Intro
• 01:21 Get to know Sean McArthur and his origins in Rust
• 08:32 The Impact of Mozilla on Sean's Career
• 10:47 A short history of Hyper
• 21:52 hyper-util, http and headers crates
• 33:46 Warp
• 36:14 Hyper's Core Focus and Future Directions
• 38:21 Integrating HTTP/2 and HTTP/3 Support
• 40:19 The reqwest crate
• 45:04 The Complexities of HTTP/3 Integration
• 48:40 Reflections on the cURL and Hyper Collaboration
• 55:51 Future Aspirations for Hyper
• 59:21 Encouraging Community Engagement in Open Source
• 01:02:40 Outro

Netstack.FM

• More information: https://netstack.fm/#episode-29
  • Original episode was: https://netstack.fm/#episode-2

• Join our Discord: https://discord.gg/29EetaSYCD
• Reach out to us: [email protected]

Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj.

episode 28: socketioxide with Théodore Prévot.

This episode features an in-depth conversation with Théodore Prévot, creator and maintainer of the Rust crate socketioxide. We explore the origins of the project, how a personal writing app led to implementing a full Socket.IO server in Rust, and what it takes to build and maintain a high-level real-time protocol on top of Tokio, Tower, and the Rust HTTP ecosystem.

Théodore walks us through the layered architecture of Engine.IO and Socket.IO, explains concepts like rooms, namespaces, acknowledgements, adapters, and connection recovery, and reflects on protocol versioning and compatibility challenges. We also dive into one of the hardest technical problems behind socketioxide: building a custom lazy JSON deserializer wrapper around Serde to efficiently route and decode mixed JSON and binary payloads.

Finally, we discuss abstraction boundaries, async runtime considerations, integration testing strategies, the possibility of a Rust client implementation, and what motivates long-term open source maintenance.

Learn more:

• https://docs.rs/socketioxide/latest/socketioxide/ — socketioxide documentation
• https://github.com/Totodore/socketioxide — socketioxide GitHub repository
• https://totodore.github.io/serde-wrapper/ — Custom Serde deserializer article
• https://socket.io/docs/v4/ — Official Socket.IO documentation
• https://github.com/socketio/engine.io-protocol — Engine.IO protocol reference
• https://www.youtube.com/watch?v=HEhhWL1oUTM — Talk featuring Théodore Prévot

Rama

If you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.org

Chapters

• 00:00 Intro
• 01:04 Get to know Théodore Prévot
• 06:43 The origins of socketioxide
• 08:50 Understanding Engine.IO and Its Role
• 11:43 The Evolution of Socket.IO and Its Features
• 22:49 Integration with Other Protocols and Frameworks
• 25:45 Understanding the boundaries of Socket.IO vs Engine.IO
• 35:38 Custom JSON Deserialization Challenges
• 40:54 Navigating Socket.IO Versioning
• 47:02 Abstraction in socketioxide
• 57:04 Future Directions for socketioxide
• 01:05:26 Outro

Netstack.FM

• More information: https://netstack.fm/#episode-28
• Join our Discord: https://discord.gg/29EetaSYCD
• Reach out to us: [email protected]

Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj

episode 27: AI Policies, OSS Maintenance and EU Open Source Academy with Daniel Stenberg.

This episode features a deep and pragmatic conversation with Daniel Stenberg, founder of cURL and president of the European Open Source Academy, reflecting on FOSDEM 2026, the growing role of open source in European policy, and what digital sovereignty means in practice; Daniel shares the motivation behind the EU funded Open Source Academy, discusses how maintainers are dealing with the rise of AI generated security reports, explains why cURL shut down its bug bounty program, and offers a balanced view on where LLM tools genuinely help in code review and security research versus where they create noise, all while highlighting the long term realities of maintaining critical infrastructure software for decades.

Learn more:

• https://curl.se — cURL website
• https://daniel.haxx.se/blog/ — Daniel Stenberg blog
• https://fosdem.org — FOSDEM
• https://github.com/bagder/fosdem — FOSDEM tips repository
• https://europeanopensource.academy — European Open Source Academy
  

Rama

If you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.org

Chapters

• 00:00 Intro
• 01:21 Navigating FOSDEM: Insights and Experiences
• 06:16 The Role of Open Source in Policy and Society
• 10:53 Polhemsrådet and European Open Source Aacademy
• 23:19 The Future of Bug Bounty Programs and AI's Role
• 32:35 Good use of LLM technologies in context of cURL
• 42:32 Daniel's personal LLM usage
• 47:28 how AI might evolve and impact cURL in future
• 53:08 The Future of AI in Software Development
• 56:02 Continuous Improvement in Curl
• 01:02:12 Mentorship and Community in Open Source
• 01:07:41 Very quick intro to some more obscure protocols supported by cURL
• 01:18:54 Outro
  

Netstack.FM

• More information: https://netstack.fm/#episode-27
• Join our Discord: https://discord.gg/29EetaSYCD
• Reach out to us: [email protected]
  

Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj

episode 26: Email protocols with Mauro De Gennaro from Stalwart Labs.

This episode features an in depth conversation with Mauro De Gennaro of Stalwart Labs that demystifies how email actually works in practice, from SMTP delivery and DNS based routing to IMAP, JMAP, spam filtering, encryption, and authentication standards like DKIM, SPF, and DMARC, all through the lens of building and operating a modern mail and collaboration server in Rust; Mauro shares his long personal journey from early BBS systems to founding Stalwart, explains why email protocols have evolved the way they have, how self hosting email can be practical and secure today, and why open standards, automation, and memory safety are key to reclaiming control over critical communication infrastructure.

Learn more:

• https://stalw.art — Website
• https://github.com/stalwartlabs — GitHub org
• https://github.com/stalwartlabs/stalwart — GitHub repository
• https://stalw.art/docs — Documentation (including installation instructions)
• https://stalw.art/slides — Product presentation slides
• https://fosdem.org/2026/schedule/event/FP8EFX-scaling-email/ — FOSDEM 2026 talk
• https://www.ietf.org/meeting/125/ — IETF 125 Shenzen

Rama

If you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.org

Chapters

• 00:00 Intro
• 00:50 Get to know Mauro De Gennaro
• 08:44 Origins of Stalwart
• 12:24 The Evolution of Stalwart and Its Features
• 14:59 Life of a mail sent to a Stalwart server
• 18:14 Understanding Email Transmission and Protocols
• 22:54 Combination of Email with Calendar and Contacts
• 26:37 Email File Attachments
• 31:56 Stalwart and ACME
• 39:44 Email Address validation
• 44:47 Exploring the Sieve Protocol for Mail Filtering
• 47:54 Email RFCs and standarization
• 54:39 Experiences at FOSDEM and the Future of Email
• 56:50 The Case for Self-Hosting Email Solutions
• 01:00:27 Backup Strategies for Self-Hosted Email Servers
• 01:04:35 Ensuring Redundancy and Reliability in Email Hosting
• 01:12:38 Comparing Email Protocols: SMTP, POP3, and IMAP
• 01:16:25 Shared Inboxes and Automated Email
• 01:24:26 Understanding Email Authentication Standards
• 01:27:54 ARC, SPF, DKIM and DMARC
• 01:33:24 Integrating AI with Email Systems
• 01:36:03 Self-Hosting Considerations
• 01:39:31 Getting Started with Stalwart
• 01:41:54 Outro

Netstack.FM

• More information: https://netstack.fm/#episode-26
• Join our Discord: https://discord.gg/29EetaSYCD
• Reach out to us: [email protected]

Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj

episode 25: FOSDEM 2026 special.

Recorded live from FOSDEM 2026.

Learn more:

• https://fosdem.org/2026/ — FOSDEM 2026 website
• https://fosdem.org/2026/schedule/event/CKANPK-programmable_networking_with_rama/ — FOSDEM 2026 rama talk
• https://www.nlnetlabs.nl/ — NLnet Labs website
• https://github.com/NLnetLabs/roto — roto github repo
• https://fosdem.org/2026/schedule/event/DS7LFX-rust-roto-calling-jit-compiled-scripts/ — FOSDEM 2026 roto talk
• https://ratatui.rs/ — ratatui website
• https://orhun.dev/ — website from Orhun

Rama

If you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.org

Chapters

• 00:00 Intro
• 00:47 Intro interview Terts (NLNetLabs)
• 02:00 Roto
• 04:06 What's next for Roto
• 06:56 Tert's reflections on FOSDEM
• 09:49 Networking and Community Building
• 11:28 Rust Week (NL)
• 12:32 Closing Thoughts and Community Encouragement
• 13:45 Intro Interview Orhun (Ratatui)
• 21:13 Reflections on FOSDEM 2026
• 22:47 Preview of next week's episode
• 23:26 Outro

Netstack.FM

• More information: https://netstack.fm/#episode-25
• Join our Discord: https://discord.gg/29EetaSYCD
• Reach out to us: [email protected]

Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj

episode 24: WebAssembly and Rust in Practice, A Conversation with Alex Crichton.

In this episode we sit down with Alex Crichton to talk about WebAssembly and Rust in practice. We discuss how Wasm grew beyond the browser into a serious runtime for servers and plugins, and why Rust fits so well in this space.

We also explore WASI, the component model, and lessons from building Wasmtime, covering performance, security, and what it takes to run Wasm in production.

Learn more:

• https://github.com/alexcrichton — Alex Crichtton on GitHub
• https://webassembly.org/ — WebAssembly overview and introduction
• https://wasi.dev/ — WASI introduction and goals
• https://component-model.bytecodealliance.org/ — WebAssembly component model documentation
• https://bytecodealliance.org/ — Bytecode Alliance home page
• https://wasmtime.dev/ — Wasmtime runtime home page
• https://docs.wasmtime.dev/ — Wasmtime documentation
• https://docs.rs/wasmtime/latest/wasmtime/ — Wasmtime Rust API documentation
• https://github.com/bytecodealliance/wasmtime — Wasmtime source code
• https://github.com/bytecodealliance/wasm-tools — wasm tools used throughout the Wasmtime ecosystem
• https://github.com/bytecodealliance/wit-bindgen/ — wit bindgen tooling for the component model
• https://webassembly.github.io/spec/ — WebAssembly specification rendering
• https://github.com/WebAssembly/WASI — WASI specification repository
• https://github.com/WebAssembly/proposals/ — Active WebAssembly proposals
• https://bytecodealliance.org/articles/ — Bytecode Alliance blog and technical articles

Rama

If you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.org

Chapters

• 00:00 Intro
• 00:42 Introduction to Alex Crichton and His Journey
• 04:14 Understanding WebAssembly: Basics and Benefits
• 07:35 Challenges of WebAssembly and DOM Access
• 16:29 Exploring WASI: The WebAssembly System Interface
• 31:11 The Relationship Between WebAssembly and WASI
• 34:43 Understanding WebAssembly Instructions
• 37:09 The Role of Compilers in WebAssembly
• 40:07 Exploring Roto and WebAssembly Integration
• 42:19 Garbage Collection in WebAssembly
• 44:17 Dynamic Libraries and Code Sharing in WebAssembly
• 45:49 Core WebAssembly and Its Layers
• 48:39 The Component Model's Evolution
• 51:25 String Handling in WebAssembly
• 54:26 Simplifying WebAssembly for Developers
• 55:30 Specifications and Documentation in WebAssembly
• 57:31 Asynchronous Support in the Component Model
• 01:01:29 Exploring WASI P3 and Async Support
• 01:10:36 More about the Component Model
• 01:22:39 The Role of the Bytecode Alliance
• 01:26:57 Akamai's Interest in WebAssembly
• 01:31:29 Exploring WebAssembly Use Cases
• 01:37:27 Future of WasmTime Development
• 01:40:24 Understanding WasmTime's Architecture
• 01:44:34 Getting Started with WasmTime
• 01:51:19 Security and Testing in WasmTime
• 01:56:11 Outro

Netstack.FM

• More information: https://netstack.fm/#episode-24
• Join our Discord: https://discord.gg/29EetaSYCD
• Reach out to us: [email protected]

Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj

episode 23 — Protocol Shorts: HTTP as an Application Bus.

This is the debut of our "Protocol Shorts" series: fast-paced, high-density conversations with one or more expert guests centered around a common theme. In the "HTTP as an application bus" episode, we’re breaking down the tunneling renaissance—specifically the clever 'protocol-within-a-protocol' hacks that are changing the game.

From hijacking H2 CONNECT to run full-duplex WebSockets, to the subtle ways we’re now nesting modern traffic inside older transports, we’re looking at how the network layer is being rewritten from the inside out.

Learn more:

• https://grpc.io — Official gRPC website.
• https://grpc.io/docs/platforms/web/ — Overview of gRPC Web
• https://github.com/hyperium/tonic — Tonic, the most popular gRPC implementation in Rust
• https://developers.google.com/protocol-buffers — Protocol Buffers documentation explaining the IDL, encoding, and ecosystem behind gRPC.
• https://datatracker.ietf.org/doc/html/rfc7540 — HTTP/2 specification
• https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API — WebSockets API overview, including framing, duplex communication, and browser support.
• https://datatracker.ietf.org/doc/html/rfc6455 — WebSocket protocol specification describing frames, ping pong, and connection upgrade.

Rama

If you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.org

Chapters

• 00:00 Welcome Lucio, 1st guest of this protocol shorts episode
• 01:52 Understanding HTTP/2 and Metadata Frames
• 05:32 Limitations of gRPC Web and Client Streaming
• 08:28 Encoding Formats: Protobuf vs JSON
• 11:18 gRPC in Browser Contexts
• 14:16 The Future of gRPC with HTTP/3 and QUIC
• 18:03 Introduction to Brecht, 2nd guest of this episode
• 20:00 Understanding HTTP/2: Features and Use Cases
• 26:34 Custom Protocols Over HTTP/2
• 31:52 Exploring WebSockets: Basics and Applications
• 37:05 WebSockets: Advanced Use Cases and Multiplexing
• 41:40 Outro

Netstack.FM

More information: https://netstack.fm/#episode-23

Join our Discord: https://discord.gg/29EetaSYCD

Reach out to us: [email protected]

Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj

episode 22 — Rust URL with Simon Sapin.

In this episode of Netstack.fm, Simon Sapin discusses building the rust-url crate based on the WHATWG URL specification. He also highlights that IDNA support was integrated to handle internationalized domain names, which includes critical security checks to prevent phishing from "confusable" characters that look identical to users.

Learn more:

• https://docs.rs/url — rust-url is an implementation of the URL Standard for the Rust programming language
• https://docs.rs/idna — IDNA (Internationalizing Domain Names in Applications) and Punycode
• https://docs.rs/idna_adapter — unicode back end for the idna crate
• https://docs.rs/form_urlencoded — Parser and serializer for the application/x-www-form-urlencoded syntax, as used by HTML forms
• https://docs.rs/percent-encoding — Percent encoding and decoding
• https://servo.org/ — official servo website
• https://url.spec.whatwg.org/ — WHATWG URL Specificaton
• https://datatracker.ietf.org/doc/html/rfc5890 — Internationalized Domain Names for Applications (IDNA) (RFC)
• https://exyr.org/ — official website of Simon Sapin

Rama

If you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.org

Chapters

• 00:00 Intro
• 00:50 Get to know Simon Sapin
• 05:35 Origin of rust-url
• 07:19 Implementing Specifications in Rust
• 10:05 Understanding IDNA and Its Importance
• 11:17 Origins of form-url / percent encoding crates
• 12:36 The Role of Percent Encoding in URLs
• 13:21 IDNA Crate Origin
• 15:41 Challenges with IDNA and Usability
• 30:13 unpacking the rust-url crate
• 39:25 Understanding URL Specifications and Compatibility
• 45:10 Url Crate Parser
• 52:41 Surprising Insights into URL Implementation
• 01:01:41 Final words
• 01:14:07 Outro

Netstack.FM

• More information: https://netstack.fm/#episode-22
• Join our Discord: https://discord.gg/29EetaSYCD
• Reach out to us: [email protected]

Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj

episode 21 — GraphQL and Rust with Tom Houlé.

In this episode of Netstack.fm, Glen and Tom Houlé discuss GraphQL's transition from a high-hype mobile data solution at Facebook to a mature enterprise technology. They explore technical challenges like the N+1 problem and persisted queries, as well as the rise of GraphQL Federation for unifying microservices in Rust-based gateways. Tom also highlights GraphQL’s future potential as a self-documenting interface for LLMs and its healthy, community-driven development.

Learn more:

• https://www.tomhoule.com — Personal website of Tom Houlé
• https://graphql.org/learn/ — Learn GraphQL
• https://www.jovidecroock.com/blog/graphql-myths/ — GraphQL Myths (about trusted documents — Jovi De Croock)
• https://benjie.dev/graphql/trusted-documents — Another great blog post about trusted documents, by Benjie
• https://www.apollographql.com/docs/graphos/schema-design/federated-schemas/federation — Introduction to GraphQL Federation (Apollo)
• https://github.com/graphql/composite-schemas-spec/ — The Composite Schemas specification, the vendor neutral next iteration of federation
• https://www.youtube.com/watch?v=E_RETbpPogw — Transforming Capital One’s Data Marketplace with Embedded Governance and a Product Mindset (enterprise adoption)
• https://relay.dev/docs/ — Relay docs
• Rust Crates:
  • https://github.com/async-graphql/async-graphql — async-graphql, the server framework
  • https://github.com/graphql-rust/graphql-client/ — graphql-client
  • https://github.com/obmarg/cynic — cynic
• https://www.youtube.com/@GraphQLFoundation — @GraphQLFoundation on YouTube
• https://www.youtube.com/@graphqltv — @GraphQL TV on YouTube
• https://grafbase.com/blog/seamless-grpc-subgraphs-with-extensions-and-composite-schemas — Seamless gRPC subgraphs with extensions and composite schemas

Rama

If you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.org

Chapters

• 00:00 Intro
• 00:39 Meet Tom Houlé
• 03:24 Origins of GraphQL
• 10:05 The Shift to Persistent Queries in GraphQL
• 18:09 GraphQL's Role in Frontend and Backend Development
• 21:11 Challenges and Criticisms of GraphQL
• 24:07 Optimizing GraphQL for Performance
• 35:06 Schema first vs Code first
• 40:44 Optimizing GraphQL Server Query Implementations
• 44:39 GraphQL Federation: A Unified Approach
• 51:08 Authentication in GraphQL: Challenges and Solutions
• 01:05:23 The Future of GraphQL: Trends and Innovations
• 01:16:03 Outro

Netstack.FM

• More information: https://netstack.fm/#episode-21
• Join our Discord: https://discord.gg/29EetaSYCD
• Reach out to us: [email protected]

Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj

episode 20 — Netstack.FM New Year Special, 2025 Wrap-Up.

This New Year special reflects on the first nineteen episodes of netstack.fm, highlighting key lessons about networking, Rust, open source, and the people behind the protocols and systems that power the internet. It also looks at the evolution of the Rama framework and sets the stage for continued learning, collaboration, and new conversations in the year ahead.

Learn more:

• https://github.com/plabayo/rama — rama repository
• https://github.com/plabayo/rama/discussions/782 — rama-0.3.0-alpha.4 release
• https://ramaproxy.org/ — rama official website
• https://ikorason.dev/posts/from-frontend-to-low-level-networking-my-journey-to-contributing-to-open-source — irfan's blog article

Chapters

• 00:00 Intro
• 00:54 Introduction and Year In Review
• 03:28 Insights from Guests and the 2025 episodes
• 22:21 Rama Testimonials
• 27:28 Rama in 2026
• 31:07 Closing Message
• 32:07 Outro

Netstack.FM

• More information: https://netstack.fm/#episode-20
• Join our Discord: https://discord.gg/29EetaSYCD
• Reach out to us: [email protected]

Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj

episode 19 — Firezone and Zero-Trust Network Security with Thomas Eizinger.

In this episode of Netstack.fm, Glen talks with Thomas Eizinger from Firezone about designing a zero trust enterprise VPN built on top of WireGuard. They break down how modern VPNs work in practice, covering virtual network adapters, split tunneling, DNS interception, policy based access, and secure packet routing using WireGuard, ICE, and TURN relays.

The discussion highlights how Firezone differs from legacy VPNs by focusing on performance, reliability, and minimal user friction, while also touching on the role of Rust and Elixir in Firezone’s architecture and the long term importance of IPv6 adoption.

Learn more:

• https://github.com/firezone/firezone — Firezone main repository
• https://github.com/firezone/firezone/tree/main/rust/relay/ebpf-turn-router — Firezone eBPF in kernel relay router
• https://www.firezone.dev/kb/architecture/critical-sequences#detailed-connection-setup — Firezone Connection Setup
• https://www.wireguard.com/papers/wireguard.pdf — WireGuard whitepaper
• https://github.com/firezone/boringtun — Firezone fork of boringtun user space WireGuard
• https://www.rfc-editor.org/rfc/rfc8656 — TURN RFC 8656
• https://x.com/firezonehq — Firezone on X
• https://x.com/oetzn — Thomas Eizinger on X
• https://hachyderm.io/@wheezle — Thomas Eizinger on Mastodon
• https://github.com/thomaseizinger — Thomas Eizinger on GitHub

Rama

If you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.org

Chapters

• 00:00 Intro
• 00:42 Introduction to Thomas Eizinger
• 05:19 Firezone's Turn implementation
• 11:00 Understanding VPNs and Firezone's Approach
• 29:27 Legacy VPNs vs. Firezone: A New Era of Networking
• 36:19 Firezone is opensource
• 37:27 Zero-Trust VPNs
• 40:28 What is WireGuard
• 43:36 Firezone's Integration with WireGuard
• 50:19 Handling Connection Failures
• 58:00 Geolocation and Relay Selection
• 01:04:45 Elixir Developer Experience (DX)
• 01:10:19 IPv6 Adoption and Future Considerations
• 01:15:03 Outro

Netstack.FM

• More information: https://netstack.fm/#episode-19
• Join our Discord: https://discord.gg/29EetaSYCD
• Reach out to us: [email protected]

Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj

episode 18 — Curiosity, Quake, and Networking with Fabien Sanglard.

Glen talks with Fabien Sanglard about curiosity driven engineering, from early computers and classic games like Doom and Quake to modern Android development and ADB. They discuss how networking evolved in games, why latency shaped multiplayer design, how Rust improves reliability in large systems, and why writing and diagrams are powerful tools for truly understanding complex technologies.

Learn more:

• https://fabiensanglard.net/ — Fabien Sanglard’s Blog
• https://fabiensanglard.net/quake_chunnel/ — How quake.exe got its TCP/IP stack

Rama

If you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.org

Chapters

• 00:00 Intro
• 01:19 Fabien's background
• 07:02 Android Debug Bridge (ADB)
• 11:05 Fabien's Blog
• 16:45 mDNS and Blog Target Audience
• 24:23 Quake TCP/IP
• 32:37 Nostalgia with Pink Glasses
• 37:58 Later Quake Versions
• 39:58 Fabien's books
• 41:53 The importance of Diagrams in documentation
• 47:19 Lessons that can be learned from ADB
• 51:58 Rust Iteration Speed
• 59:22 Outro

Netstack.FM

• More information: https://netstack.fm/#episode-18
• Join our Discord: https://discord.gg/29EetaSYCD
• Reach out to us: [email protected]

Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj

episode 17 — Early Web History and Interlisp with Larry Masinter.

We sit down with internet pioneer and longtime IETF contributor Larry Masinter to revisit the origins of many technologies developers use every day. From his early days at Xerox PARC to co-authoring foundational RFCs on HTTP, URIs, and more, Larry shares first-hand stories that connect the early web to the world we build in now. The conversation also explores his current passion project: reviving the Interlisp environment as a living historical system.

Learn more:

• https://larrymasinter.net/ — Official website from Larry Masinter
• https://www.rfc-editor.org/rfc/rfc2616 — RFC 2616 – HTTP/1.1 Specification
• https://www.rfc-editor.org/rfc/rfc3986 — RFC 3986 – URI Generic Syntax
• https://www.rfc-editor.org/rfc/rfc2324 — RFC 2324 – Hypertext Coffee Pot Control Protocol
• https://www.rfc-editor.org/rfc/rfc2732 — RFC 2732 – Literal IPv6 Addresses in URLs
• https://datatracker.ietf.org/doc/html/draft-masinter-dated-uri — Draft: the 'tdb' and 'duri' URI schemes, based on dated URIs
• https://interlisp.org — The Interlisp Revival Project

Rama

If you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.org

Chapters

• 00:00 Intro
• 00:34 Introduction to Larry Masinter
• 05:32 The Intellectual Environment at Xerox PARC
• 06:49 The Interlisp Project and Its Impact
• 10:05 Transitioning to Document Servers and HTTP
• 12:02 Resources, Gopher and the Early Web
• 15:45 Why did HTTP succeed where Gopher faded away
• 20:56 Larry's Involvement in Web Standards and Protocols
• 25:11 Reviving Interlisp post-pandemic
• 27:13 interlisp.org, 5 years later
• 32:57 The Tradition of April 1st RFCs
• 33:51 Invention of Hypertext Coffee Pot Control Protocol (1998)
• 37:04 The Invention of HTCPCP
• 40:55 Exploring URI Schemes
• 47:58 Form-Based File Upload
• 49:12 The Politics of Web Standards
• 01:05:12 The Evolution of Web Protocols
• 01:05:53 Developing in the Interlisp Environment
• 01:14:03 Goals of the Interlisp Revival Project
• 01:23:39 Collaborations and Future Aspirations
• 01:25:09 Outro

Netstack.FM

• More information: https://netstack.fm/#episode-17
• Join our Discord: https://discord.gg/29EetaSYCD
• Reach out to us: [email protected]

Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj

episode 16 — WebRTC and Sans IO with Martin Algesten.

We sit down with Rust developer Martin Algesten for a deep dive into WebRTC and the Sans IO approach to protocol design. Martin traces the surprising origins of WebRTC, explains why real time media over UDP is both powerful and painfully complex, and walks through how peer to peer connections work under the hood. The conversation then shifts to Sans IO design, why it matters for clean protocol implementations in Rust, and how Martin applies it in his own WebRTC stack, str0m.

Learn more:

• https://github.com/algesten — Github profile of Martin Algesten
• https://github.com/algesten/str0m — A Sans I/O WebRTC implementation in Rust
• https://github.com/algesten/dimpl — DTLS 1.2 implementation (Sans‑IO, Sync)
• https://datatracker.ietf.org/doc/rfc8489/ — Session Traversal Utilities for NAT (STUN)
• https://datatracker.ietf.org/doc/rfc8656/ — Traversal Using Relays around NAT (TURN)
• https://www.w3.org/TR/webrtc/ — WebRTC: Real-Time Communication in Browsers

Rama

If you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.org

Chapters

• 00:00 Intro
• 00:40 Get to know Martin Algensten
• 06:16 A bit of WebRTC history
• 09:38 WebRTC 101
• 30:05 P2P and Stun
• 36:00 WebRTC: stages and flow from start to finish
• 45:43 How Martin got into WebRTC and started the str0m project
• 52:36 What is Sans IO?
• 01:06:36 Why DTLS is not Sans IO in Str0m, but Str0m is
• 01:18:34 Outro

Netstack.FM

• More information: https://netstack.fm/#episode-16
• Join our Discord: https://discord.gg/29EetaSYCD
• Reach out to us: [email protected]

Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj

In Episode 15 of netstack.fm, Glen sits down with Edward and Noah from Cloudflare to unpack the design of Pingora, the Rust based proxy framework that now powers Cloudflare’s origin facing traffic. The discussion covers why Cloudflare moved away from NGINX, how Pingora differs from Oxy, and what it takes to operate a high performance global proxy at massive scale. Listeners will learn about connection reuse strategies, dynamic traffic handling, gRPC and protocol translation, custom HTTP implementations, TLS backend choices, and the practical trade offs of Rust, Tokio, and work stealing in real production systems. It is an episode full of deep technical insights into building and operating modern networking infrastructure.

Learn more:

• https://blog.cloudflare.com/how-we-built-pingora-the-proxy-that-connects-cloudflare-to-the-internet/ — Pingora's introduction blog
• https://blog.cloudflare.com/pingora-open-source/ — Pingora launch blog post (Cloudflare)
• https://github.com/vicanso/pingap — pingap, built on top of pingora
• https://blog.cloudflare.com/road-to-grpc/ — Cloudflare gRPC and gRPC Web article
• https://github.com/hyperium/h2 — Hyperium h2 crate
• https://github.com/cloudflare/quiche — Quiche (QUIC and HTTP3 implementation)
• https://blog.cloudflare.com/technical-breakdown-http2-rapid-reset-ddos-attack/ — Cloudflare Rapid Reset HTTP2 attack analysis
• https://csrc.nist.gov/pubs/fips/140-3/final — NIST FIPS 140-3 publication
• https://blog.cloudflare.com/introducing-oxy/ — Introducing Oxy (Cloudflare)
• https://blog.cloudflare.com/oxy-extensibility/ — Oxy's extensions via generics
• https://blog.cloudflare.com/20-percent-internet-upgrade/ — Oxidizing other CDN components for performance
• https://github.com/cloudflare/foundations — Cloudflare's foundations crate

Rama

If you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.org

Chapters

• 00:00 Intro
• 00:37 A bit of background on the episode and our guests
• 03:18 The Evolution of Proxy Frameworks: Oxy vs. Pingora
• 14:59 The Philosophy Behind Pingora's Design
• 20:53 Understanding Pingora's Bare Bones Structure
• 27:50 Metrics and Observability in Pingora
• 39:19 Caching Strategies and Backend Structures
• 42:56 Usage of OnceCell
• 45:39 TLS Implementations and Their Importance
• 50:51 Dynamic Traffic Management and gRPC Support
• 01:02:10 Optimizing Connection Reuse with Pingora
• 01:07:10 The Importance of Layer 7 Processing
• 01:11:16 The Shift from Static to Dynamic Web Traffic
• 01:18:48 Performance Improvements with Rust and Tokio
• 01:26:00 Memory Management and Allocation Strategies
• 01:37:59 Outro

Netstack.FM

• More information: https://netstack.fm/#episode-15
• Join our Discord: https://discord.gg/29EetaSYCD
• Reach out to us: [email protected]

Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj

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 website
• https://github.com/NLnetLabs/cascade — A friendly DNSSEC signing solution
• https://indico.dns-oarc.net/event/55/contributions/1186 — slides of conference talk introducing Cascade
• https://github.com/NLnetLabs/rotonda — Modular, programmable BGP Engine
• https://github.com/NLnetLabs/roto — strongly-typed, compiled embedded scripting language for Rust
• https://www.youtube.com/watch?v=7xJEFPlfy7Y — EuroRust 2025 talk by Terts on Roto
• https://docs.rs/domain/latest/domain/new/base/wire/index.html — domain's zerocopy module
• https://bal-e.org/blog/ — Blog from Arya
• https://2026.rustweek.org/ — RustWeek 2026 (with open CFP until EOY 2025)

Rama

If you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.org

Chapters

• 00:00 Intro
• 01:14 Backgrounds of Terts and Arya
• 10:37 Overview of NLnet Labs
• 17:43 Understanding DNSSEC
• 25:29 The Role of Cascade in DNSSEC
• 41:06 Understanding Roto and Rotonda
• 45:55 The Evolution of Roto's Scripting Language
• 49:34 Integration and Efficiency in Roto
• 52:05 Real-World Applications of Roto
• 01:00:36 The Importance of Data Structures in Performance
• 01:06:34 Optimization Strategies for High Performance
• 01:17:14 Zero-Copy Techniques in DNS Handling
• 01:26:06 Outro

Netstack.FM

• More information: https://netstack.fm/#episode-14
• Join our Discord: https://discord.gg/29EetaSYCD
• Reach out to us: [email protected]

Music 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 stack
• https://dpdk.org — The Data Plane Development Kit for high-performance packet processing and kernel bypass
• https://github.com/cloudflare/quiche — Cloudflare’s QUIC and HTTP/3 implementation, mentioned for MASQUE support w/ tokio support
• https://github.com/tokio-rs/tokio — The asynchronous runtime used by Ping Proxies for concurrency
• https://github.com/hyperium/h2 — Rust’s HTTP/2 library, referenced as part of Ping Proxies’ stack
• https://github.com/hyperium/h3 — Rust’s HTTP/3 library, used for advanced proxy tunneling
• https://datatracker.ietf.org/doc/rfc9298 — Proxying UDP in HTTP (MASQUE)
• https://ipxo.com — Marketplace for leasing IP addresses, discussed in how Ping acquires IP ranges
• https://pawns.app/sdk/ — Example of SDK-based residential proxy provider referenced in the episode
  

Rama

If you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.org

Chapters

• 00:00 Intro
• 00:41 Introduction to Proxies and Joe's background
• 03:42 Understanding Pink Proxies and Their Offerings
• 06:52 The Technical Journey: From Squid to Rust
• 09:47 Proxy Types: Data Center vs. Residential
• 12:42 Building a Proxy Infrastructure
• 15:44 Challenges with HTTP Protocols
• 18:39 The Importance of Customization in Proxy Development
• 21:38 Team Dynamics and Future Growth
• 29:32 Transitioning to Rust Development
• 30:59 Understanding HTTP Protocols
• 32:40 Exploring HTTP/2 and HTTP/3
• 34:05 The Future of Proxying with Mask
• 36:14 Evaluating New Technologies for Proxies
• 37:51 Developing for End User Devices
• 39:49 Challenges in Network Stack Development
• 41:15 Proxying Non-HTTP Traffic
• 42:51 TCP/IP Fingerprinting Explained
• 47:57 The Importance of TCP/IP Fingerprinting
• 53:28 Performance Considerations in User Space TCP
• 58:22 Competing in the Proxy Market
• 01:00:05 Cancellation Safety in Rust Concurrency
• 01:03:53 Outro
  

Netstack.FM

• More information: https://netstack.fm/#episode-13
• Join our Discord: https://discord.gg/29EetaSYCD
• Reach out to us: [email protected]
  

Music 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 Company
• https://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 Project
• https://www.sigcomm.org/ — ACM SIGCOMM Conference
• https://www.usenix.org/conference/nsdi26 — USENIX NSDI Symposium
• https://oxide-and-friends.transistor.fm/episodes/the-frontend-of-the-computer — Oxide & Friends (Dropshot Episode)

Rama

If you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.org

Chapters

• 00:00 Intro
• 00:44 Meet Ryan Goodfellow
• 06:23 Building Large-Scale Test Beds
• 07:46 The future of the internet
• 10:54 Overview of Oxide's Rack Scale Computer
• 19:36 Exploring BGP and Routing Protocols
• 26:02 The X4C Compiler and Its Origins
• 39:43 Programming for Tofino and Observability
• 45:10 Life of packets of an HTTP Web (Oxide Rack) server
• 01:01:58 Exploring Maghemite: The Routing Stack
• 01:12:45 Future Directions: Rust-Based Operating Systems
• 01:19:28 Testing Strategies and the Falcon Framework
• 01:27:25 Outro

Netstack.FM

• More information: https://netstack.fm/#episode-12
• Join our Discord: https://discord.gg/29EetaSYCD
• Reach out to us: [email protected]

Music 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 Inden
• https://max-inden.de/post/fast-udp-io-in-firefox/ — Fast UDP I/O for Firefox in Rust — by Max Inden
• https://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 Gosu
• https://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 Transport
• https://datatracker.ietf.org/doc/html/rfc9114 — RFC 9114 – HTTP/3
• https://datatracker.ietf.org/doc/html/rfc9462 — RFC 9462 – Discovery of Designated Resolvers
• https://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 MsQuic
• https://developer.mozilla.org/en-US/docs/Web/API/WebTransport — WebTransport API documentation
• https://datatracker.ietf.org/wg/masque/about/ — MASQUE (Proxy) protocol introduction
• https://www.ietf.org/ — Internet Engineering Task Force (IETF)
• https://www.ietf.org/meeting/ — IETF Meetings

Rama

If you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.org

Chapters

• 00:00 Intro
• 00:38 Introduction to Max Inden
• 03:27 Max Inden's Journey to Mozilla
• 06:32 The Role of IETF in Internet Design
• 09:42 QUIC and HTTP/3 in Firefox
• 12:27 Understanding HTTP/3 Upgrade Mechanisms
• 15:15 Challenges with UDP and Firefox's Networking Stack
• 18:15 Optimizing UDP I/O for Performance
• 21:36 Cross-Platform Performance Considerations
• 24:23 Network Drivers and Their Impact
• 27:18 Exploring Happy Eyeballs and Connection Strategies
• 30:07 WebTransport and Future of QUIC
• 32:56 Contributions to Firefox and Open Source
• 36:05 Happy Eyeballs and related
• 56:15 Github Git Hosting
• 57:24 Quic Usage within Firefox
• 01:03:02 Closing Thoughts and call to Action
• 01:06:44 Outro

Netstack.FM

• More information: https://netstack.fm/#episode-11
• Join our Discord: https://discord.gg/29EetaSYCD
• Reach out to us: [email protected]

Music 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 verifier
• https://github.com/rust-lang/rust/issues/99571 — Safe Transmute tracking issue
• https://github.com/rust-lang/unsafe-code-guidelines — Unsafe Code Guidelines WG
• https://docs.rs/zerocopy/latest/zerocopy/ — ZeroCopy documentation
• https://docs.rs/zerocopy-derive/latest/zerocopy_derive/ — ZeroCopy derive macros
• https://fuchsia.dev/fuchsia-src/get-started/learn/intro/architecture — Fuchsia networking architecture
• https://docs.kernel.org/networking/scaling.html — Scaling in the Linux Networking Stack
• https://www.youtube.com/watch?v=rFejpH_tAHM — dotGo 2015 - Rob Pike - Simplicity is Complicated

Rama

If you like this podcast you might also like our modular network framework in Rust: https://ramaproxy.org

Chapters

• 00:00 Intro
• 00:39 Introduction to Joshua Liebow-Feeser
• 01:34 Joshua's Journey into Software Development
• 11:41 The Origins of Netstack 3
• 17:21 The Philosophy Behind Netstack 3
• 23:03 The Role of Rust in Networking
• 42:57 The Concept and Development of ZeroCopy
• 53:10 Understanding Zero Copy and Its Constraints
• 55:11 Exploring Memory Management in Networking
• 59:23 Challenges with Variable Length Data Formats
• 01:04:20 Async Programming and Its Implications
• 01:11:13 Performance Considerations in Networking
• 01:16:50 Ambition in Software Design and API Simplicity
• 01:32:13 The Future of Networking and Rust's Role
• 01:42:42 Outro

Netstack.FM

• More information: https://netstack.fm/#episode-10
• Join our Discord: https://discord.gg/29EetaSYCD
• Reach out to us: [email protected]

Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj.