netstack.fm

netstack.fm

By Plabayo BVTechnology
Download on the App Store

All netstack.fm episodes

  • Firezone and Zero-Trust Network Security with Thomas Eizinger

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

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

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

    Learn more:

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

    Rama

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

    Chapters

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

    Netstack.FM

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

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

    1 hr 17 min
  • Curiosity, Quake, and Networking with Fabien Sanglard

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

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

    Learn more:

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

    Rama

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

    Chapters

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

    Netstack.FM

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

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

    1 hr 1 min
  • Early Web History and Interlisp with Larry Masinter

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

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

    Learn more:

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

    Rama

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

    Chapters

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

    Netstack.FM

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

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

    1 hr 27 min
  • WebRTC and Sans IO with Martin Algesten

    episode 16 — WebRTC and Sans IO with Martin Algesten.

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

    Learn more:

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

    Rama

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

    Chapters

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

    Netstack.FM

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

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

    1 hr 20 min
  • Pingora with Edward and Noah from Cloudflare
    episode 15 — Pingora with Edward and Noah from Cloudflare.

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

    Learn more:

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

    Rama

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

    Chapters

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

    Netstack.FM

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

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

    1 hr 39 min
  • Roto And Cascade with Terts and Arya from NLnet Labs

    Episode 14 – Roto And Cascade with Terts and Arya from NLnet Labs.

    In this episode we have a conversation with Terts and Arya from NLnet Labs. Together we explore their paths into systems programming, the mission of NLnet Labs, and the critical internet infrastructure the organization maintains. The discussion spans DNSSEC, large scale DNS operations, Rotonda, and the Roto scripting language, with deep dives into performance engineering, zero copy design, and building resilient open source networking software. It is a technical episode that highlights the people and ideas behind essential internet protocols.

    Learn more:

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

    Rama

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

    Chapters

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

    Netstack.FM

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

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

    1 hr 27 min
  • Inside Ping Proxies with Joseph Dye

    Episode 13 – Inside Ping Proxies with Joseph Dye.

    In this episode of Netstack.fm, Glen from Plabayo talks with Joseph Dye (Joe), founding engineer at Ping Proxies, about building large-scale proxy infrastructure in Rust. Joe shares how he went from art student to programmer, joining Ping when it was a tiny startup running on Python and Squid. He explains how they rebuilt everything in Rust, creating performant HTTP and SOCKS5 proxies and managing massive IP networks for web scraping. The conversation covers the evolution of their stack, challenges with HTTP versions, TCP/IP fingerprinting, user-space networking with DPDK, and the adoption of MASQUE and HTTP/3. Joe also reflects on Rust’s safety benefits, being the only Rust engineer at Ping, and how the company stays competitive through technical innovation rather than size.

    Learn more:

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

    Rama

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

    Chapters

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

    Netstack.FM

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

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

    1 hr 5 min
  • Oxide Networking with Ryan Goodfellow

    Episode 12 – Oxide Networking with Ryan Goodfellow.

    A conversation with Ryan Goodfellow about Rust networking at Oxide. We will explore the Oxide computer stack with a focus on network, including their fully integrated cloud computer, programmable networking with P4 and Dendrite, the Maghemite routing stack, and OPTE — a Rust-based packet engine running inside the kernel. Ryan also shares how his background in large-scale network testbeds led him to help design Oxide’s rack-scale system and its modern approach to routing, observability, and hardware–software co-design.

    Learn more:

    • https://oxide.computer/ — Oxide Computer Company
    • https://github.com/oxidecomputer/opte — OPTE (Oxide Packet Transformation Engine)
    • https://github.com/oxidecomputer/maghemite — Maghemite (Routing Stack)
    • https://github.com/oxidecomputer/dendrite — Dendrite (P4 Switch Control)
    • https://github.com/oxidecomputer/hubris — Hubris (Rust OS for Microcontrollers)
    • https://github.com/oxidecomputer/falcon — Falcon (Virtual Rack Testbed)
    • https://rfd.shared.oxide.computer/rfd/0347 — RFD 347 (Delay-Driven Multipath Routing (DDM))
    • https://groups.csail.mit.edu/ana/Publications/PubPDFs/Tussle2002.pdf — The Tussle in Cyberspace (Paper)
    • https://named-data.net/project/ndn/ — Named Data Networking Project
    • https://www.sigcomm.org/ — ACM SIGCOMM Conference
    • https://www.usenix.org/conference/nsdi26 — USENIX NSDI Symposium
    • https://oxide-and-friends.transistor.fm/episodes/the-frontend-of-the-computer — Oxide & Friends (Dropshot Episode)

    Rama

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


    Chapters

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

    Netstack.FM

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

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

    1 hr 29 min
  • Modern networking in Firefox with Max Inden

    Episode 11 – Modern networking in Firefox with Max Inden.

    A conversation with Max Inden, Staff Software Engineer at Mozilla, about modernizing Firefox’s networking stack in Rust. We cover his work on the QUIC and HTTP/3 stack — improving UDP I/O, congestion control, and overall performance — and why QUIC matters as a fast, encrypted, and evolvable transport for HTTP/3, WebTransport, and beyond.

    Learn more:

    • https://max-inden.de/ — Personal website of Max Inden
    • https://max-inden.de/post/fast-udp-io-in-firefox/ — Fast UDP I/O for Firefox in Rust — by Max Inden
    • https://archive.fosdem.org/2025/schedule/event/fosdem-2025-4229-getaddrinfo-sucks-everything-else-is-much-worse/ — getaddrinfo sucks, everything else is much worse — Talk by Valentin Gosu
    • https://github.com/mozilla/neqo — Mozilla Neqo (HTTP/3 and QUIC stack)
    • https://datatracker.ietf.org/doc/html/rfc9000 — RFC 9000 – QUIC: A UDP-Based Multiplexed and Secure Transport
    • https://datatracker.ietf.org/doc/html/rfc9114 — RFC 9114 – HTTP/3
    • https://datatracker.ietf.org/doc/html/rfc9462 — RFC 9462 – Discovery of Designated Resolvers
    • https://www.rfc-editor.org/rfc/rfc8484.html — RFC 8484 – DNS Queries over HTTPS (DoH)
    • https://datatracker.ietf.org/doc/draft-ietf-happy-happyeyeballs-v3/ — Happy Eyeballs Version 3 (Draft)
    • https://github.com/microsoft/msquic — Microsoft MsQuic
    • https://developer.mozilla.org/en-US/docs/Web/API/WebTransport — WebTransport API documentation
    • https://datatracker.ietf.org/wg/masque/about/ — MASQUE (Proxy) protocol introduction
    • https://www.ietf.org/ — Internet Engineering Task Force (IETF)
    • https://www.ietf.org/meeting/ — IETF Meetings

    Rama

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


    Chapters

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

    Netstack.FM

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

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

    1 hr 8 min
  • zerocopy with Joshua Liebow-Feeser

    Episode 10 – zerocopy with Joshua Liebow-Feeser.

    A conversation with Joshua Liebow-Feeser, the developer behind netstack3 and the creator of zerocopy, a crate that makes zero-cost memory manipulation effortless. Originally built for Fuchsia, zerocopy is now used by over 400 crates on crates.io, with nearly 300 million downloads.

    We explore the origins of Fuchsia, the creation and purpose of zerocopy, how it works, and why you might want to use it. And of course, we get to know Joshua and his journey so far.

    Learn more:

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

    Rama

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


    Chapters

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

    Netstack.FM

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

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

    1 hr 44 min