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.

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.

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.

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

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

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.

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

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

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

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

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

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

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

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

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

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: hello@netstack.fm

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

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: hello@netstack.fm

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

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: hello@netstack.fm

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

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: hello@netstack.fm

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: hello@netstack.fm

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

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: hello@netstack.fm

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

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: hello@netstack.fm
  

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

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: hello@netstack.fm

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

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: hello@netstack.fm

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

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: hello@netstack.fm

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

A deep dive into the world of asynchronous networking in Rust with Lucio Franco, maintainer of Tonic, Tower, Tokio, and Hyper. We explore the origins and design of gRPC and its Rust implementation, Tonic—how it came to be, what problems it solves, and why it matters. Along the way, Lucio shares insights into open source collaboration, Google’s work on gRPC for Rust, and what the future might hold for the broader async Rust ecosystem.

Learn more:

• https://github.com/hyperium/tonic — Tonic on GitHub
• https://github.com/tokio-rs/tokio — Tokio runtime
• https://github.com/tower-rs/tower — Tower library
• https://github.com/tower-rs/tower-grpc — Archived tower-grpc project
• https://grpc.io/ — gRPC official site
• https://github.com/hyperium/tonic/blob/master/examples/helloworld-tutorial.md — Tonic "hello world" tutorial
• https://docs.rs/tonic/latest/tonic/ — Tonic technical documentation
• https://twitter.github.io/finagle/ — Finagle
• https://github.com/linkerd/linkerd2 — linkerd2

Rama

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

Chapters

• 00:00 Intro
• 00:45 Introduction to Lucio
• 06:50 Lucio's Journey in Rust and Open Source
• 14:45 Future of tower
• 29:48 Exploring gRPC: Concepts and Features
• 36:33 gRPC vs HTTP: A Comparative Analysis
• 43:38 The Role of Proxies in gRPC Communication
• 54:12 Integrating Tonic with Other Stacks
• 59:15 Collaboration with Google on Tonic
• 01:07:03 Getting Started with Tonic and gRPC
• 01:09:48 Tonic Ecosystem: Recommended Crates
• 01:14:19 The Naming of Tonic
• 01:16:38 gRPC Web: Bridging the Browser Gap
• 01:23:16 Proxying gRPC Data: Considerations and Challenges
• 01:27:08 Outro

Netstack.FM

• More information: https://netstack.fm/#episode-9
• 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.

In this episode our guest is Bruno Dal Bo Silva, Staff Software Engineer at Google. We will dive into his path into networking and Rust, and the story behind netstack3, the Rust-based networking stack built for Google’s Fuchsia operating system. We cover its origins from the Go-based netstack, why Rust was chosen, and the challenges of implementing a full range of protocols — from TCP and UDP with their POSIX socket API to the many less-visible but essential pieces like ARP, ICMP, IPv6, DHCP, and more. We hope you brought a bowl as you're in or a juicy letter soup with this one. Bruno also shares insights on where he sees the future of netstack3 — including its potential beyond Google.

Learn more:

• https://fuchsia.dev/
• netstack3 source code: https://fuchsia.googlesource.com/fuchsia/+/refs/heads/master/src/connectivity/network/netstack3/
• netstack3 publishing tracking bug: https://fxbug.dev/448156020
• Fast UDP I/O for Firefox in Rust: https://max-inden.de/post/fast-udp-io-in-firefox
• RFC 2462 - SLAAC: https://www.rfc-editor.org/rfc/rfc2462
• smoltcp (Rust TCP/IP stack for embedded): https://github.com/m-labs/smoltcp

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 Bruno and his Journey
• 04:37 Bruno's Engineering Background and Its Impact
• 06:56 Exploring Fuchsia: Overview and Architecture
• 10:08 Transitioning to NetStack 3: The Rust Revolution
• 17:35 Diving into Networking Protocols: Life of a Packet
• 24:45 Understanding ARP and Ethernet Protocols
• 28:00 Dynamic Host Configuration Protocol (DHCP) Explained
• 34:41 The Future of Networking: IPv6 and Happy Eyeballs
• 40:52 QUIC Protocol: User Space vs Kernel Space
• 46:53 More about netstack3 and unsafe code usage
• 55:22 Async usage in Netstack3
• 01:00:36 Comparing netstack3 with smolltcp
• 01:04:50 Running your own TCP stack on the linux platform
• 01:06:25 Roadmap to get fuchsia on crates.io
• 01:11:37 Closing Thoughts and Future Directions
• 01:15:32 Outro

Netstack.FM

• More information: https://netstack.fm/#episode-8
• 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.

In this episode, we go through Dirkjan's extensive experience in software development, particularly focusing on Rust, TLS, and QUIC protocols.

We explore Dirkjan his journey working on QUIC implementations to his contributions to Rust TLS and Hickory DNS. The conversation also delves into the ACME protocol and the Instant Domain Search project.

Dirkjan shares insights on the future of Rustls and the importance of community support in open-source projects.

Learn more:

• https://dirkjan.ochtman.nl/
• https://github.com/rustls/rustls
• rustls 0.24 tracking issue: https://github.com/rustls/rustls/issues/2400
• HickoryDNS Let's Encrypt tracking issue: https://github.com/hickory-dns/hickory-dns/issues/2725
• https://github.com/djc/instant-acme
• https://instantdomainsearch.com/

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 Introduction to Dirkjan Ochtman
• 02:02 Dirkjan's Rustls contributor origins
• 04:18 Quic implications on Rustls
• 13:35 Exploring the H3 Protocol and Its Challenges
• 16:47 Contributions to Hickory DNS
• 22:59 instant ACME
• 28:43 R2D2 — Connection Pooling
• 32:13 the EPP Protocol
• 34:40 Insights from Working with Domain Registrars
• 35:36 Rustls and Safety
• 50:31 The Future of Rust TLS and Its Ecosystem
• 54:50 Outro

Netstack.FM

• More information: https://netstack.fm/#episode-7
• 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.

In this episode of netstack.fm, Glen speaks with Daniel Stenberg, the creator and maintainer of Curl, one of the most widely used networking tools on the internet. They discuss Daniel's journey into programming and networking, the evolution of Curl from a simple tool to a comprehensive solution supporting multiple protocols, and the challenges of maintaining such a large open-source project. Daniel shares insights on the importance of community involvement, the complexities of debugging across various platforms, and his reflections on a 30-year journey with Curl. The conversation highlights the significance of open-source contributions and the future of Curl as a project.

Learn more:

• https://curl.se/
• https://daniel.haxx.se/
• https://daniel.haxx.se/blog/
• https://github.com/curl/curl

Rama

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

Chapters

• 00:00 Intro
• 00:36 Introduction to Curl and Daniel Stenberg
• 05:20 Understanding Protocols and Specifications
• 08:10 The Birth of Curl: From IRC Bot to Networking Tool
• 12:46 Curl's Evolution and Protocol Support
• 15:58 The Decision to Focus on Client-Side Development
• 17:40 Current Protocol Support in Curl
• 22:17 Managing Complexity in Curl's Codebase
• 25:33 The Choice of C as the Programming Language
• 28:33 Continuous Development and Community Engagement
• 30:16 Balancing Work, Family, and Open Source Contributions
• 36:37 Transitioning to Full-Time Work on Curl
• 41:38 The Challenge of Funding Open Source Projects
• 46:44 Exploring Commercial Opportunities with Curl
• 49:53 Ensuring Curl's Longevity and Succession Planning
• 51:58 Tackling Technical Challenges in Open Source Development
• 57:05 Reflecting on a 30-Year Journey with Curl
• 01:00:07 Outro

Netstack.FM

• More information: https://netstack.fm/#episode-6
• 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.

In this episode of Netstack.fm, Glen speaks with Carl Lerche, the creator and maintainer of the Tokio Runtime, about his journey into technology, the evolution of programming languages, and the impact of Rust on the software development landscape. They discuss the rise of async programming, the development of networking libraries, and the future of Rust in infrastructure. Carl shares insights on the creation of the Bytes crate, the implications of io_uring, and his role at Amazon. The conversation also touches on the upcoming Tokio conference and the introduction of Toasty, a new query engine for Rust.

Learn more:

• https://tokio.rs/
• https://www.tokioconf.com/
• https://github.com/carllerche

Rama

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

Chapters

• 00:00 Intro
• 00:45 Origins of Carl
• 04:01 Parallel between DotCom Bubble and current AI wave
• 05:52 Origins of Carl... Continued
• 09:12 Carl discovers Rust in 2014
• 13:40 Creation of mio
• 17:39 mio, tokio and futures
• 19:15 Powers of Rust
• 25:57 io_uring
• 26:12 The Evolution of IO-URing and Its Practicality
• 29:40 Carl's job at Amazon and Tokio
• 30:51 Maintaining Tokio today and beyond
• 32:30 Toasty
• 38:58 AI in Software Development: A Tool for Productivity
• 49:20 First Tokio Conference
• 53:10 Final words
• 55:17 Outro

Netstack.FM

• More information: https://netstack.fm/#episode-4
• 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.

You can find a remastered version of this episode as episode 32 (https://netstack.fm/#episode-32) for an improved listening experience with better audio quality. Released on the 24th of March 2026. Please listen to that episode instead of this one.

In this episode, Glen interviews Delaney, the creator of DataStar, a lightweight framework designed for building real-time collaborative web applications. Delaney shares his journey from being a 3D artist to a developer, emphasizing the importance of hypermedia and real-time visualization. The conversation delves into the efficiency of DataStar, its use of Server-Sent Events (SSE), and the framework's potential for collaborative web experiences. Delaney also discusses the challenges of WebSockets and introduces future projects like DarkStar, aimed at enhancing networking capabilities. Overall, the episode highlights the transformative potential of DataStar in modern web development. In this conversation, Delaney discusses the intricacies of DataStar, a real-time system for handling large volumes of messages. He emphasizes the importance of simplicity in programming, the significance of measuring performance, and the role of abstraction in software development. Delaney also explains the core functions of DataStar, including patch elements and signals, and how they facilitate real-time interactivity. The discussion touches on offline support, the growth of the DataStar community, and the non-profit model that supports its development. Delaney encourages developers to engage with the community and emphasizes the importance of building solutions to real problems.

Learn more about Datastar and Hypermedia:

• https://data-star.dev/
• https://data-star.dev/reference/datastar_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
• 00:42 Delaney and his background
• 02:39 The Evolution of Hypermedia and Real-Time Systems
• 06:27 SSE and Compression
• 15:33 The Social Web
• 23:01 Why use datastar?
• 29:42 Web Transport and Darkstar
• 33:55 DataStar and Future Directions
• 46:04 Understanding Abstraction in Programming
• 50:19 DataStar: Key Functions and Concepts
• 53:27 Signals in DataStar: When to Use Them
• 57:25 Front-End Validation and User Experience
• 59:27 Offline Support and Web Applications
• 01:02:56 The Growth of DataStar and Community Engagement
• 01:07:09 The Challenges of Web Development
• 01:09:26 AI and Its Role in Development
• 01:13:22 DataStar and WebTransport: Future Directions
• 01:16:33 Dynamic Content and DataStar's Use Cases
• 01:18:35 Funding and Sustainability of Open Source Projects
• 01:31:02 Outro

Netstack.FM

• More information: https://netstack.fm/#episode-4
• 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.

In this conversation, Chris Batterbee, co-founder of Metoro, discusses the importance of observability in modern software systems, particularly in Kubernetes environments. He explains how Metoro leverages eBPF technology to simplify observability by automatically instrumenting applications. The discussion also covers the integration of OpenTelemetry, the challenges faced by developers in implementing observability, and the potential of AI in diagnosing issues. Chris shares insights from his experience with Y Combinator and the competitive landscape of observability tools, emphasizing the unique position of Metoro in the market.

Learn more about OpenTelemetry, eBPF and Metoro:

• https://opentelemetry.io/
• https://ebpf.io/
• https://metoro.io/
• metoro demo: https://demo.us-east.metoro.io/guardian?startEnd=&service=
• OpenTelemetry metric examplar: https://opentelemetry.io/docs/specs/otel/metrics/data-model/#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:41 Chris Batterbee his background
• 02:27 eBPF intro in context of Metoro
• 04:20 eBPF + OpenTelemetry
• 06:37 Opentelemetry Experience
• 14:19 WASM
• 16:10 eBPF and Windows
• 16:59 Y Combinator Experience
• 23:52 OpenTelemetry standard
• 25:50 Platform is king
• 26:53 eBPF accessibility
• 28:30 Future of Prometheus
• 29:41 Metoro and LLMs
• 32:14 Replacing Sentry and the like
• 33:46 Profiling
• 35:39 Metoro Subscription Models
• 36:37 Final words
• 38:57 Outro

Netstack.FM

• More information: https://netstack.fm/#episode-3
• 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.

You can find a remastered version of this episode as episode 29 (https://netstack.fm/#episode-29) for an improved listening experience with better audio quality. Released on the 3rd of March 2026. Please listen to that episode instead of this one.

In this episode, Glen interviews Sean McArthur, the creator and maintainer of the Hyper ecosystem. They discuss Sean's journey in software engineering, the evolution of Rust and asynchronous programming, and the growth of Hyper from its inception at Mozilla to its current status in the web development landscape. Sean shares insights on the creation of hyper, hyper-util, http, headers, the Warp framework, and the challenges of integrating HTTP/3 and QUIC. The conversation also touches on collaboration with cURL, the FFI layer, and Sean's aspirations for the future of Hyper and the broader ecosystem.

Learn more about Sean McArthur, Hyper and Warp:

• https://seanmonstar.com/
• https://seanmonstar.com/sponsor/
• https://hyper.rs/
• https://seanmonstar.com/blog/async-hyper/
• https://github.com/hyperium/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 Intro
• 00:45 Introduction to Sean and the Hyper Ecosystem
• 01:48 Sean's entrance into Rust
• 06:17 The Impact of Mozilla on Sean's Career
• 07:54 The Development of Hyper and Its Challenges
• 13:20 Realizing Hyper's Long-Term Potential
• 15:32 The Creation of hyper-util and Its purpose
• 17:32 http and headers crates
• 22:40 Navigating API Design Challenges
• 22:47 The Philosophy Behind Warp Framework
• 26:43 Integrating HTTP/2 and HTTP/3 Support
• 28:54 The Evolution of the Requests Library
• 30:17 Commercial Aspects of Hyper
• 31:31 The Complexities of HTTP/3 Integration
• 34:35 Reflections on the cURL and Hyper Collaboration
• 38:50 Maintaining Open Source Independence
• 40:16 Future Aspirations for Hyper
• 41:23 Encouraging Community Engagement in Open Source
• 42:28 Final words
• 43:57 Outro

Netstack.FM

• More information: 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.

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

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.