Skip to content
Sign in
Artwork for netstack.fm
Technology

netstack.fm

Plabayo BV

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.

You can send your questions to hello@netstack.fm or come chat with us on Discord. Netstack.FM is produced by Plabayo BV, a European software studio based in Gent, Belgium, focused on building resilient, interoperable, and secure digital infrastructure.

Play
Open in
  • 21 episodes
  • weekly
  • Avg 1 hr 3 min
  • English

Episodes 21

NewestOldestLongest
All20Unplayed20In progress0Played0
Counted on this page — what you have heard stays on this device, so it is not something the list can be paged by.
  • S2 · E1
    October 29 · 1 hr 24 min

    Small Crates Behind Big Rust Systems

    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: hello@netstack.fm Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj

    • Transcript
  • S1 · E38
    May 26 · 33 min

    Building and testing network stacks with Rama

    Episode 38: Building and testing network stacks with Rama. 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. Chapters 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 Netstack.FM More information: https://netstack.fm/#episode-38 Join our Discord: https://discord.gg/29EetaSYCD Reach out to us: hello@netstack.fm Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj

    • Transcript
  • S1 · E37
    May 5 · 1 hr 6 min

    dial9: from black box to insight in Tokio

    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: hello@netstack.fm Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj

    • Transcript
  • S1 · E36
    April 25 · 16 min

    Protocol Shorts: WireGuard

    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: hello@netstack.fm Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj.

    • Transcript
  • S1 · E35
    April 15 · 56 min

    OpenTelemetry, eBPF and Metoro (Remastered)

    Remaster of: Season 1 · Episode 3 — OpenTelemetry, eBPF, and Metoro Episode 35 – 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: hello@netstack.fm Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj.

    • Transcript
  • S1 · E34
    April 9 · 1 hr 35 min

    Tokio with Carl Lerche (Remastered)

    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: hello@netstack.fm Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj.

    • Transcript
  • S1 · E33
    March 31 · 27 min

    Protocol Shorts: TLS Encrypted Client Hello

    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: hello@netstack.fm Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj.

    • Transcript
  • S1 · E32
    March 24 · 1 hr 32 min

    Datastar and Hypermedia (Remastered)

    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: hello@netstack.fm Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj.

    • Transcript
  • S1 · E31
    March 17 · 16 min

    Protocol Shorts: MITM Proxies and Transparent L4 Interception

    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: hello@netstack.fm Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj

    • Transcript
  • S1 · E30
    March 10 · 1 hr 21 min

    uReq with Martin Algesten

    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: hello@netstack.fm Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj

    • Transcript
  • S1 · E29
    March 3 · 1 hr 3 min

    Hyper With Sean McArthur (Remastered)

    Remaster of: Season 1 · Episode 2 — Hyper with Sean McArthur Episode 29 – 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: hello@netstack.fm Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj.

    • Transcript
  • S1 · E28
    February 24 · 1 hr 6 min

    socketioxide with Théodore Prévot

    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: hello@netstack.fm Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj

    • Transcript
  • S1 · E27
    February 17 · 1 hr 19 min

    AI Policies, OSS Maintenance and EU Open Source Academy with Daniel Stenberg

    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: hello@netstack.fm Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj

    • Transcript
  • S1 · E26
    February 10 · 1 hr 42 min

    Email protocols with Mauro De Gennaro from Stalwart Labs

    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: hello@netstack.fm Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj

    • Transcript
  • S1 · E25
    February 3 · 24 min

    FOSDEM 2026 special

    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: hello@netstack.fm Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj

    • Transcript
  • S1 · E24
    January 27 · 1 hr 57 min

    WebAssembly and Rust in Practice, A Conversation with Alex Crichton

    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: hello@netstack.fm Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj

    • Transcript
  • S1 · E23
    January 20 · 42 min

    Protocol Shorts: HTTP as an Application Bus

    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: hello@netstack.fm Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj

    • Transcript
  • S1 · E22
    January 13 · 1 hr 15 min

    Rust URL with Simon Sapin

    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: hello@netstack.fm Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj

    • Transcript
  • S1 · E21
    January 6 · 1 hr 17 min

    GraphQL and Rust with Tom Houlé

    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: hello@netstack.fm Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj

    • Transcript
  • S1 · E20
    Dec 30, 2025 · 33 min

    Netstack.FM New Year Special, 2025 Wrap-Up

    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: hello@netstack.fm Music for this episode was composed by Dj Mailbox. Listen to his music at https://on.soundcloud.com/4MRyPSNj8FZoVGpytj

    • Transcript
Showing 1–20 of 21 episodes