Afleveringen

  • Building and testing network stacks with Rama

    Building and testing network stacks with Rama

    · netstack.fm
    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.Chapters00:00 Intro00:48 Introduction to Rama and Brecht's Role02:46 Understanding Services in Rama08:22 Testing and Mocking in Rama10:23 gRPC and TCP Configuration Issues15:35 Evolution of Extensions in Rama24:58 Building with Rama and Rama's Horizon31:52 OutroNetstack.FMMore information: https://netstack.fm/#episode-38Join our Discord: https://discord.gg/29EetaSYCDReach out to us: [email protected]

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

  • dial9: from black box to insight in Tokio

    dial9: from black box to insight in Tokio

    · netstack.fm

    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 Cohenhttps://tokio.rs/blog/2026-03-18-dial9 — Introducing dial9: a flight recorder for Tokiohttps://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 spechttps://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 Intro02:01 Meet Russell and Jess05:27 The Mission of the Rust Team at Amazon11:47 Integration with OpenTelemetry and Tracing13:49 The Evolution of Dial 917:17 Comparing Dial 9 with Existing Tools20:07 Continue exploring history and development and UX of Dial933:47 Building Self-Serve Solutions36:22 perf sched38:30 Task Dumps41:17 Dial 9: almost a free lunch43:00 Cross-Platform Considerations for Dial 946:20 Future Features and Improvements for Dial 950:20 Dial 9 usage today54:31 Considerations before using Dial 901:03:05 Getting Started with Dial 901: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

  • Zijn er afleveringen die ontbreken?

    Klik hier om de feed te vernieuwen.

  • Protocol Shorts: WireGuard

    Protocol Shorts: WireGuard

    · netstack.fm

    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 WireGuardhttps://www.wireguard.com/papers/wireguard.pdf — WireGuard whitepaperhttps://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 Intro00:18 Introduction to WireGuard01:41 WireGuard Properties03:24 Why WireGuard?07:43 Current Use Cases and Adoption of WireGuard11:42 Get started with WireGuard14:37 Final Words15:17 Outro

    Netstack.FM

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

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

  • OpenTelemetry, eBPF and Metoro (Ep 3 Remastered)

    OpenTelemetry, eBPF and Metoro (Ep 3 Remastered)

    · netstack.fm
    Episode 35 – OpenTelemetry, eBPF and Metoro (Ep 3 Remastered).

    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 Intro00:34 Into to Chris Battarbee02:36 Understanding eBPF and Its Role in Observability10:13 Integrating OpenTelemetry with eBPF15:05 Challenges and Experiences with OpenTelemetry22:28 Future of eBPF and OpenTelemetry in Different Environments27:53 YCombinator Experience29:31 Insights from Y Combinator Experience32:31 Networking and Community in Y Combinator34:43 Raising Funds Post-Y Combinator35:39 Post-Y Combinator Relationship with YC36:27 OpenTelemetry Pain Points38:31 The Future of OpenTelemetry and Standards39:47 Competition with Major Cloud Providers41:40 Understanding eBPF and Its Challenges43:24 Prometheus vs. OpenTelemetry44:40 AI Integration in Telemetry45:36 Metoro49:03 Profiling51:43 Metoro Payment Models53:57 Customer Engagement and Support55:09 Outro

    Netstack.FM

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

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

  • Tokio with Carl Lerche (Ep 5 Remastered)

    Tokio with Carl Lerche (Ep 5 Remastered)

    · netstack.fm

    Episode 34 — Tokio with Carl Lerche (Ep 5 Remastered).

    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 Intro01:26 Introduction to Carl and His Journey in Tech16:30 How Carl got into Rust21:18 How Mio/Tokio begun47:15 The Evolution of IO-URing and Its Practicality53:11 Amazon's Adoption of Rust and Tokyo55:06 Transitioning Leadership in the Tokyo Project57:15 Toasty01:08:55 AI in Software Development: A Tool for Productivity01:25:53 First Tokio Conference01:34:28 Outro

    Netstack.FM

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

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

  • Protocol Shorts: TLS Encrypted Client Hello

    Protocol Shorts: TLS Encrypted Client Hello

    · netstack.fm

    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 Hellohttps://blog.cloudflare.com/encrypted-client-hello/ — Practical explanation of ECH and deploymenthttps://developer.mozilla.org/en-US/docs/Web/Security/Transport_Layer_Security — TLS fundamentals and handshake overviewhttps://www.cloudflare.com/learning/ssl/what-happens-in-a-tls-handshake/ — another TLS handshake overviewhttps://tls12.xargs.org/ — a tls 1.2 handshake, explained byte by bytehttps://tls13.xargs.org/ — a tls 1.3 handshake, explained byte by bytehttps://www.rfc-editor.org/rfc/rfc8446 — TLS 1.3 specification and handshake detailshttps://blog.mozilla.org/security/2021/01/07/encrypted-client-hello-the-future-of-esni-in-firefox/ — Firefox perspective on ECH adoptionhttps://blog.mozilla.org/security/2021/01/07/encrypted-client-hello-the-future-of-esni-in-firefox/ — Firefox perspective on ECH adoptionhttps://samueloph.dev/blog/i-use-curl-with-ech-btw-in-debian/ — blog article about adding ECH into curlhttps://www.rfc-editor.org/rfc/rfc9460 — a DNS record type that publishes connection parameters for a servicehttps://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 Intro00:27 Understanding the TLS Handshake Process06:54 Understanding Middle Boxes and Network Behavior08:33 The Privacy Gap in Network Traffic14:08 Current Usage and Future of ECH18:00 Consequences of ECH for Existing Infrastructures24:19 Future of ECH: Privacy vs. Trust26: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.

  • Datastar and Hypermedia (Ep 4 Remastered)

    Datastar and Hypermedia (Ep 4 Remastered)

    · netstack.fm

    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_prohttps://hypermedia.systems/

    Rama

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

    Chapters

    00:00 Intro01:12 Delaney and his background03:09 The Evolution of Hypermedia and Real-Time Systems06:58 SSE and Compression16:04 The Social Web23:32 Why use datastar?30:12 Web Transport and Darkstar34:26 Final Thoughts on DataStar and Future Directions46:35 Understanding Abstraction in Programming49:18 Event Sourcing and Efficiency in Systems50:50 DataStar: Key Functions and Concepts53:58 Signals in DataStar: When to Use Them57:56 Front-End Validation and User Experience59:58 Offline Support and Web Applications01:03:26 The Growth of DataStar and Community Engagement01:07:39 The Challenges of Web Development01:09:56 AI and Its Role in Development01:13:52 DataStar and WebTransport: Future Directions01:17:03 Dynamic Content and DataStar's Use Cases01:19:06 Funding and Sustainability of Open Source Projects01: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.

  • Protocol Shorts: MITM Proxies and Transparent L4 Interception

    Protocol Shorts: MITM Proxies and Transparent L4 Interception

    · netstack.fm

    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 Bushttps://ramaproxy.org/book/proxies/intro.html — Intro to proxies in the Ramabookhttps://ramaproxy.org/book/proxies/http.html — HTTP(S) proxies in the Rama boohttps://ramaproxy.org/book/proxies/socks5.html — SOCKS5 proxies in the Rama bookhttps://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 bookhttps://ramaproxy.org/book/proxies/operate/transparent.html — Operating transparent proxies with Ramahttps://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 Intro01:00 Understanding Proxies: The Basics01:18 Diving Deeper into Proxy Types04:16 Layer 4 Proxies: A New Approach05:23 Challenges of Transparent Proxies07:53 Bridging Conversations: A New Insight09:53 Example: HTTPS request within a SOCKS5 tunnel13:41 Layer 4 Proxies and Protocol Reconstruction15:15 Outro

    Netstack.FM

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

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

  • uReq with Martin Algesten

    uReq with Martin Algesten

    · netstack.fm

    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 clienthttps://github.com/algesten/ureq/blob/main/src/run.rs - example on how uReq and Sans IO come togetherhttps://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Expect — Expect 100 Continuehttps://github.com/algesten — Github profile of Martin Algestenhttps://github.com/algesten/str0m — A Sans I/O WebRTC implementation in Rusthttps://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 Intro00:58 Get to know Martin06:46 Evolution of uReq: From Simplicity to Compliance20:35 Sans IO26:58 uReq prior to Sans IO30:57 Practical Examples: Handling Complex Protocols50:54 Sans IO in Str0m and uReq55:01 Handling Proxies and DNS Resolution01:02:51 The Future of uReq and uReq Proto01:07:06 Sans IO and h201:09:00 Final Thoughts and Community Feedback01: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

  • Hyper With Sean McArthur (Ep 2 Remastered)

    Hyper With Sean McArthur (Ep 2 Remastered)

    · netstack.fm
    Episode 29 – Hyper with Sean McArthur (Ep 2 Remastered).

    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/hyperhttps://github.com/seanmonstar/warphttps://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 notes00:37 Intro01:21 Get to know Sean McArthur and his origins in Rust08:32 The Impact of Mozilla on Sean's Career10:47 A short history of Hyper21:52 hyper-util, http and headers crates33:46 Warp36:14 Hyper's Core Focus and Future Directions38:21 Integrating HTTP/2 and HTTP/3 Support40:19 The reqwest crate45:04 The Complexities of HTTP/3 Integration48:40 Reflections on the cURL and Hyper Collaboration55:51 Future Aspirations for Hyper59:21 Encouraging Community Engagement in Open Source01:02:40 Outro

    Netstack.FM

    More information: https://netstack.fm/#episode-29Original episode was: https://netstack.fm/#episode-2Join our Discord: https://discord.gg/29EetaSYCDReach out to us: [email protected]

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

  • socketioxide with Théodore Prévot

    socketioxide with Théodore Prévot

    · netstack.fm

    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 documentationhttps://github.com/Totodore/socketioxide — socketioxide GitHub repositoryhttps://totodore.github.io/serde-wrapper/ — Custom Serde deserializer articlehttps://socket.io/docs/v4/ — Official Socket.IO documentationhttps://github.com/socketio/engine.io-protocol — Engine.IO protocol referencehttps://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 Intro01:04 Get to know Théodore Prévot06:43 The origins of socketioxide08:50 Understanding Engine.IO and Its Role11:43 The Evolution of Socket.IO and Its Features22:49 Integration with Other Protocols and Frameworks25:45 Understanding the boundaries of Socket.IO vs Engine.IO35:38 Custom JSON Deserialization Challenges40:54 Navigating Socket.IO Versioning47:02 Abstraction in socketioxide57:04 Future Directions for socketioxide01:05:26 Outro

    Netstack.FM

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


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

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

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

    · netstack.fm

    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 websitehttps://daniel.haxx.se/blog/ — Daniel Stenberg bloghttps://fosdem.org — FOSDEMhttps://github.com/bagder/fosdem — FOSDEM tips repositoryhttps://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 Intro01:21 Navigating FOSDEM: Insights and Experiences06:16 The Role of Open Source in Policy and Society10:53 Polhemsrådet and European Open Source Aacademy23:19 The Future of Bug Bounty Programs and AI's Role32:35 Good use of LLM technologies in context of cURL42:32 Daniel's personal LLM usage47:28 how AI might evolve and impact cURL in future53:08 The Future of AI in Software Development56:02 Continuous Improvement in Curl01:02:12 Mentorship and Community in Open Source01:07:41 Very quick intro to some more obscure protocols supported by cURL01:18:54 Outro

    Netstack.FM

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

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

  • Email protocols with Mauro De Gennaro from Stalwart Labs

    Email protocols with Mauro De Gennaro from Stalwart Labs

    · netstack.fm

    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 — Websitehttps://github.com/stalwartlabs — GitHub orghttps://github.com/stalwartlabs/stalwart — GitHub repositoryhttps://stalw.art/docs — Documentation (including installation instructions)https://stalw.art/slides — Product presentation slideshttps://fosdem.org/2026/schedule/event/FP8EFX-scaling-email/ — FOSDEM 2026 talkhttps://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 Intro00:50 Get to know Mauro De Gennaro08:44 Origins of Stalwart12:24 The Evolution of Stalwart and Its Features14:59 Life of a mail sent to a Stalwart server18:14 Understanding Email Transmission and Protocols22:54 Combination of Email with Calendar and Contacts26:37 Email File Attachments31:56 Stalwart and ACME39:44 Email Address validation44:47 Exploring the Sieve Protocol for Mail Filtering47:54 Email RFCs and standarization54:39 Experiences at FOSDEM and the Future of Email56:50 The Case for Self-Hosting Email Solutions01:00:27 Backup Strategies for Self-Hosted Email Servers01:04:35 Ensuring Redundancy and Reliability in Email Hosting01:12:38 Comparing Email Protocols: SMTP, POP3, and IMAP01:16:25 Shared Inboxes and Automated Email01:24:26 Understanding Email Authentication Standards01:27:54 ARC, SPF, DKIM and DMARC01:33:24 Integrating AI with Email Systems01:36:03 Self-Hosting Considerations01:39:31 Getting Started with Stalwart01:41:54 Outro

    Netstack.FM

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

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

  • FOSDEM 2026 special

    FOSDEM 2026 special

    · netstack.fm

    episode 25: FOSDEM 2026 special.

    Recorded live from FOSDEM 2026.

    Learn more:

    https://fosdem.org/2026/ — FOSDEM 2026 websitehttps://fosdem.org/2026/schedule/event/CKANPK-programmable_networking_with_rama/ — FOSDEM 2026 rama talkhttps://www.nlnetlabs.nl/ — NLnet Labs websitehttps://github.com/NLnetLabs/roto — roto github repohttps://fosdem.org/2026/schedule/event/DS7LFX-rust-roto-calling-jit-compiled-scripts/ — FOSDEM 2026 roto talkhttps://ratatui.rs/ — ratatui websitehttps://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 Intro00:47 Intro interview Terts (NLNetLabs)02:00 Roto04:06 What's next for Roto06:56 Tert's reflections on FOSDEM09:49 Networking and Community Building11:28 Rust Week (NL)12:32 Closing Thoughts and Community Encouragement13:45 Intro Interview Orhun (Ratatui)21:13 Reflections on FOSDEM 202622:47 Preview of next week's episode23:26 Outro

    Netstack.FM

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

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

  • WebAssembly and Rust in Practice, A Conversation with Alex Crichton

    WebAssembly and Rust in Practice, A Conversation with Alex Crichton

    · netstack.fm

    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 GitHubhttps://webassembly.org/ — WebAssembly overview and introductionhttps://wasi.dev/ — WASI introduction and goalshttps://component-model.bytecodealliance.org/ — WebAssembly component model documentationhttps://bytecodealliance.org/ — Bytecode Alliance home pagehttps://wasmtime.dev/ — Wasmtime runtime home pagehttps://docs.wasmtime.dev/ — Wasmtime documentationhttps://docs.rs/wasmtime/latest/wasmtime/ — Wasmtime Rust API documentationhttps://github.com/bytecodealliance/wasmtime — Wasmtime source codehttps://github.com/bytecodealliance/wasm-tools — wasm tools used throughout the Wasmtime ecosystemhttps://github.com/bytecodealliance/wit-bindgen/ — wit bindgen tooling for the component modelhttps://webassembly.github.io/spec/ — WebAssembly specification renderinghttps://github.com/WebAssembly/WASI — WASI specification repositoryhttps://github.com/WebAssembly/proposals/ — Active WebAssembly proposalshttps://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 Intro00:42 Introduction to Alex Crichton and His Journey04:14 Understanding WebAssembly: Basics and Benefits07:35 Challenges of WebAssembly and DOM Access16:29 Exploring WASI: The WebAssembly System Interface31:11 The Relationship Between WebAssembly and WASI34:43 Understanding WebAssembly Instructions37:09 The Role of Compilers in WebAssembly40:07 Exploring Roto and WebAssembly Integration42:19 Garbage Collection in WebAssembly44:17 Dynamic Libraries and Code Sharing in WebAssembly45:49 Core WebAssembly and Its Layers48:39 The Component Model's Evolution51:25 String Handling in WebAssembly54:26 Simplifying WebAssembly for Developers55:30 Specifications and Documentation in WebAssembly57:31 Asynchronous Support in the Component Model01:01:29 Exploring WASI P3 and Async Support01:10:36 More about the Component Model01:22:39 The Role of the Bytecode Alliance01:26:57 Akamai's Interest in WebAssembly01:31:29 Exploring WebAssembly Use Cases01:37:27 Future of WasmTime Development01:40:24 Understanding WasmTime's Architecture01:44:34 Getting Started with WasmTime01:51:19 Security and Testing in WasmTime01:56:11 Outro

    Netstack.FM

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

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

  • Protocol Shorts: HTTP as an Application Bus

    Protocol Shorts: HTTP as an Application Bus

    · netstack.fm

    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 Webhttps://github.com/hyperium/tonic — Tonic, the most popular gRPC implementation in Rusthttps://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 specificationhttps://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 episode01:52 Understanding HTTP/2 and Metadata Frames05:32 Limitations of gRPC Web and Client Streaming08:28 Encoding Formats: Protobuf vs JSON11:18 gRPC in Browser Contexts14:16 The Future of gRPC with HTTP/3 and QUIC18:03 Introduction to Brecht, 2nd guest of this episode20:00 Understanding HTTP/2: Features and Use Cases26:34 Custom Protocols Over HTTP/231:52 Exploring WebSockets: Basics and Applications37:05 WebSockets: Advanced Use Cases and Multiplexing41: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

  • Rust URL with Simon Sapin

    Rust URL with Simon Sapin

    · netstack.fm

    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 languagehttps://docs.rs/idna — IDNA (Internationalizing Domain Names in Applications) and Punycodehttps://docs.rs/idna_adapter — unicode back end for the idna cratehttps://docs.rs/form_urlencoded — Parser and serializer for the application/x-www-form-urlencoded syntax, as used by HTML formshttps://docs.rs/percent-encoding — Percent encoding and decodinghttps://servo.org/ — official servo websitehttps://url.spec.whatwg.org/ — WHATWG URL Specificatonhttps://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 Intro00:50 Get to know Simon Sapin05:35 Origin of rust-url07:19 Implementing Specifications in Rust10:05 Understanding IDNA and Its Importance11:17 Origins of form-url / percent encoding crates12:36 The Role of Percent Encoding in URLs13:21 IDNA Crate Origin15:41 Challenges with IDNA and Usability30:13 unpacking the rust-url crate39:25 Understanding URL Specifications and Compatibility45:10 Url Crate Parser52:41 Surprising Insights into URL Implementation01:01:41 Final words01:14:07 Outro

    Netstack.FM

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

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

  • GraphQL and Rust with Tom Houlé

    GraphQL and Rust with Tom Houlé

    · netstack.fm

    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 GraphQLhttps://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 Benjiehttps://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 federationhttps://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 docsRust Crates:https://github.com/async-graphql/async-graphql — async-graphql, the server frameworkhttps://github.com/graphql-rust/graphql-client/ — graphql-clienthttps://github.com/obmarg/cynic — cynichttps://www.youtube.com/@GraphQLFoundation — @GraphQLFoundation on YouTubehttps://www.youtube.com/@graphqltv — @GraphQL TV on YouTubehttps://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 Intro00:39 Meet Tom Houlé03:24 Origins of GraphQL10:05 The Shift to Persistent Queries in GraphQL18:09 GraphQL's Role in Frontend and Backend Development21:11 Challenges and Criticisms of GraphQL24:07 Optimizing GraphQL for Performance35:06 Schema first vs Code first40:44 Optimizing GraphQL Server Query Implementations44:39 GraphQL Federation: A Unified Approach51:08 Authentication in GraphQL: Challenges and Solutions01:05:23 The Future of GraphQL: Trends and Innovations01:16:03 Outro

    Netstack.FM

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

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

  • Netstack.FM New Year Special, 2025 Wrap-Up

    Netstack.FM New Year Special, 2025 Wrap-Up

    · netstack.fm

    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 repositoryhttps://github.com/plabayo/rama/discussions/782 — rama-0.3.0-alpha.4 releasehttps://ramaproxy.org/ — rama official websitehttps://ikorason.dev/posts/from-frontend-to-low-level-networking-my-journey-to-contributing-to-open-source — irfan's blog article

    Chapters

    00:00 Intro00:54 Introduction and Year In Review03:28 Insights from Guests and the 2025 episodes22:21 Rama Testimonials27:28 Rama in 202631:07 Closing Message32:07 Outro

    Netstack.FM

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

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

  • Firezone and Zero-Trust Network Security with Thomas Eizinger

    Firezone and Zero-Trust Network Security with Thomas Eizinger

    · netstack.fm

    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 repositoryhttps://github.com/firezone/firezone/tree/main/rust/relay/ebpf-turn-router — Firezone eBPF in kernel relay routerhttps://www.firezone.dev/kb/architecture/critical-sequences#detailed-connection-setup — Firezone Connection Setuphttps://www.wireguard.com/papers/wireguard.pdf — WireGuard whitepaperhttps://github.com/firezone/boringtun — Firezone fork of boringtun user space WireGuardhttps://www.rfc-editor.org/rfc/rfc8656 — TURN RFC 8656https://x.com/firezonehq — Firezone on Xhttps://x.com/oetzn — Thomas Eizinger on Xhttps://hachyderm.io/@wheezle — Thomas Eizinger on Mastodonhttps://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 Intro00:42 Introduction to Thomas Eizinger05:19 Firezone's Turn implementation11:00 Understanding VPNs and Firezone's Approach29:27 Legacy VPNs vs. Firezone: A New Era of Networking36:19 Firezone is opensource37:27 Zero-Trust VPNs40:28 What is WireGuard43:36 Firezone's Integration with WireGuard50:19 Handling Connection Failures58:00 Geolocation and Relay Selection01:04:45 Elixir Developer Experience (DX)01:10:19 IPv6 Adoption and Future Considerations01:15:03 Outro

    Netstack.FM

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

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

  • Laat meer zien