• 53 minutes 8 seconds
    RustRover with Orhun Parmaksız
    Welcome to the final episode of this season of Rust in Production. My guest is Orhun Parmaksız from JetBrains, and we talk about building developer tools with Rust.

    JetBrains is best known for IntelliJ IDEA, Kotlin, and a long line of IDEs for professional software teams. In the Rust world, that now includes RustRover: a commercial IDE built on the IntelliJ platform, with deep Rust support for navigation, refactoring, debugging, testing, and large codebases.

    This episode is about where Rust fits into that world. We talk about why JetBrains does not plan to rewrite the IntelliJ platform in Rust, why Fleet used Rust for its File System Daemon, how Air builds on parts of Fleet's architecture, and why JetBrains prefers out-of-process Rust helpers over JNI inside the JVM. We also get into RustRover's internals: PSI, THIR, MIR-based expression evaluation in the debugger, procedural macro sandboxing, library stubs, parser regression testing, cargo-nextest support, and the practical trade-offs between JetBrains' indexing model and rust-analyzer's Salsa-based approach.
    Links From The Episode

    Official Links
    30 July 2026, 4:00 pm
  • 54 minutes 34 seconds
    Rust Foundation with Bec Rumbul, Lori Lorusso, and David Wood
    Most Rust developers use the language, compiler, package registry, and tooling every day without thinking too much about the organization that helps keep parts of that ecosystem funded and sustainable. This episode is a re-introduction to the Rust Foundation: what it does, what it does not do, how it relates to the Rust Project, and why that distinction matters for teams using Rust professionally. 

    My guests are Rebecca Rumbul, Executive Director and CEO of the Rust Foundation, Lori Lorusso, Director of Outreach at the Rust Foundation, and David Wood, Principal Software Engineer at Arm, Compiler Team Co-Lead in the Rust Project, and a Rust Foundation board member. Together we talk about the practical side of ecosystem stewardship: infrastructure, security, interop, maintainer support, governance, corporate membership, open-source funding, and the pressure new technologies like AI put on language ecosystems. 
    About the Rust Foundation

    The Rust Foundation is an independent non-profit organization supporting the success, sustainability, and positive impact of the Rust programming language. Its work includes funding and supporting ecosystem infrastructure, security and interoperability initiatives, maintainer support, project administration, community programs, events, and collaboration with member companies and donors. The Foundation is separate from the Rust Project. The Rust Project governs the language, compiler, standard library, and technical direction through its own teams and decision-making processes. The Foundation provides organizational, financial, legal, and operational support around that work, without owning Rust’s technical roadmap. 

    About the Guests

    Rebecca Rumbul is the Executive Director and CEO of the Rust Foundation. She leads the Foundation’s work on organizational strategy, member engagement, sustainability, and support for the broader Rust ecosystem. Lori Lorusso is Director of Outreach at the Rust Foundation. Her work connects the Foundation with the Rust community, member organizations, trainers, contributors, and companies adopting Rust in production. David Wood is a Principal Software Engineer at Arm, CE-SW Rust Team Lead, Compiler Team Co-Lead in the Rust Programming Language Project, and a board member of the Rust Foundation. In this episode, David adds the perspective of someone involved in Rust’s technical work as well as Foundation governance. 
    Links From The Episode Official Links
    16 July 2026, 4:00 pm
  • 43 minutes 11 seconds
    Rising with Dylan Brown
    Most Rust in Production stories are about scale and performance. This one is a story about low-cost phones and patchy mobile connections in Africa, where a student is learning maths over WhatsApp. The whole point is to support hundreds of thousands of students cheaply enough to run at government scale.
    My guest is Dylan Brown, a Senior Engineering Manager at Rising Academies, and he comes at Rust from an angle of being the person who signs off on using Rust for a new project.
    For Dylan, it's about what Rust enables: lower compute costs, boring deployments, painless refactors, and code reviews that focus on business logic instead of null checks.
    About Rising Academies
    Rising Academies is an education company founded in Sierra Leone in 2014 during the Ebola crisis. It helps governments deliver better learning at scale, working with and through national public school systems. Across seven randomized controlled trials, students in Rising-supported schools have learned on average 2.4x faster each year than their peers. Today Rising supports more than 400,000 students across 1,400 public schools in West and East Africa. Its technology group builds WhatsApp-based tools designed for the realities of limited connectivity and low-cost devices, including Rori (a maths tutor) and Tari (a teacher assistant).
    About Dylan Brown
    Dylan Brown is a Senior Engineering Manager at Rising Academies, where he leads the development of educational tools deployed across several African countries. He has over a decade in software development and years of experience with conversational systems, from public-transport data in South Africa to a fintech company whose chatbots handled millions in transactions. He now focuses on building trustworthy, accessible technology for resource-constrained environments, and it was Dylan who led the decision to adopt Rust for a new part of Rising's stack.
    Links From The Episode
    • Why I like Rust as an Engineering Leader - Dylan's blog post about the project
    • axum - The ergonomic, Tokio-based web framework powering the backend
    • sqlx - The async, pure-Rust SQL toolkit with compile-time checked queries
    • cargo-xtask - Instead of writing Python scripts for your project, you can just write Rust scripts
    • pydantic - A Python package that forces you to care about types in Python, coincidentally partially written in Rust
    • Postman - A graphical API client useful for writing end-to-end tests
    • Bruno - An open-source alternative to Postman
    • turn.io - A platform for building WhatsApp-based apps

    Official Links
    2 July 2026, 4:00 pm
  • 1 hour 32 seconds
    ClickHouse with Alexey Milovidov and Austin Bonander
    There's a particular kind of pressure that comes with maintaining software at the very bottom of someone else's stack. ClickHouse lives in exactly that spot: roughly 1.5 million lines of mostly C++ and tens of millions of tests every single day.

    So what happens when you start introducing Rust into a codebase like that? Not as a rewrite, but linked into a C++ server with a CMake build process that has to be reproducible and FIPS compliant? In today's episode, we get into the messy, interesting reality. We talk about the question of whether the hardest part is Rust the language or Rust the ecosystem.

    My guests come at this from two very different angles. Alexey Milovidov is the creator of ClickHouse and its CTO. He started the project back in 2009 and has spent decades thinking about performance, correctness, and what it actually takes to build a production database. Austin Bonander is a Senior Software Engineer at ClickHouse and a renowned open-source maintainer of sqlx. He works close to the Rust tooling and the CLI. Together we talk about where Rust fits inside a C++ monolith, what it would take for Rust to earn a rewrite of core components, supply-chain and compliance headaches, and whether Rust is heading for the same accumulation of regrets that every "trendy" language eventually accumulates.
    About ClickHouse
    ClickHouse is an open-source, column-oriented OLAP database management system built for real-time analytics over very large datasets. The first version was written in 2009, it went into production in 2012, and it was open-sourced in 2016. Today it's roughly 1.5 million lines of mostly C++, exercised by tens of millions of automated tests per day and a heavy regime of sanitizers and linters. ClickHouse is known for its raw query performance, and it powers analytics workloads at companies all over the world, from observability and logging platforms to large-scale data warehouses.
    About Alexey Milovidov
    Alexey Milovidov is the creator of ClickHouse and the CTO of ClickHouse Inc. He started the project in 2009 while working at Yandex and has guided its evolution from an internal analytics tool into one of the most popular open-source databases in the world. He's spent his career obsessing over performance, correctness, and the kind of low-level engineering discipline it takes to keep a database trustworthy at scale.
    About Austin Bonander
    Austin Bonander is a Senior Software Engineer at ClickHouse, where he works on Rust tooling and the ClickHouse CLI. He is a long-time member of the Rust community and a maintainer of sqlx, the async, pure-Rust SQL toolkit. Through that work he has thought deeply about database protocols, API ergonomics, and the long-term maintenance burden of widely used open-source libraries.
    Links From The Episode
    • OLAP - A type of database used for analytics, not storing relational data
    • sqlx - The async, pure-Rust SQL toolkit Austin maintains
    • Official /r/rust "Who's Hiring" thread for job-seekers and job-offerers - Where Austin found the Clickhouse job
    • Clickhouse's C++ & Rust Journey - Alexeys talk at P99 CONF 2025
    • No-Panic Rust: A Nice Technique for Systems Programming - Using linker checks to guarantee no panic calls in Rust code
    • delta-kernel-rs - A Rust implementation of the Delta Lake kernel, with a non-trivial dependency graph
    • ring - BoringSSL crypto code packaged as a Rust crate
    • H3 - Uber’s Geo Hashing using hexagons, currently used in ClickHouse
    • H3O - The same H3 Geo Hashing algorithm implemented in Rust, with better performance
    • stdx - An attempt at creating an extended standard library with commonly used crates
    • Hyrum's Law - With enough users, every observable behavior of your system will be depended on by somebody
    • Corrosion - CMake integration for Rust, used to link Rust into a C++ build
    • Cargo - Rust's build system and package manager, not designed for multi-language monorepos
    • CMake - The build system that dominates the ClickHouse server
    • Poco - The C++ libraries used by the ClickHouse server, without HTTP/2 support
    • hyper - A fast HTTP implementation for Rust

    Official Links
    18 June 2026, 4:00 pm
  • 1 hour 12 minutes
    Veo with Anders Hellerup Madsen and Gorm Casper
    I don't know about you, but to me there are few things as interesting as the hardware/software interface: the point where carefully written code meets the messy, physical world of sensors, lenses, and real-time constraints. It's where a clever abstraction either holds up or falls apart the moment a real signal hits it.
    That makes Veo a perfect guest. The Copenhagen-based company builds AI-powered cameras that record and analyze sports matches, from grassroots football pitches to professional clubs, and then turn hours of raw footage into something coaches and players can actually use: automatic highlights, player tracking, and match analysis. To get there, they have to capture panoramic video on a custom camera, follow the action without an operator, and crunch an enormous amount of data, reliably and at scale.
    My guests sit on both sides of that interface. Anders Hellerup Madsen works close to the metal on the camera itself, on the embedded firmware and the GStreamer media pipeline that turns raw sensor data into video. Gorm Casper works further up the stack, on the backend that ingests, processes, and analyzes those matches in Rust. Together we talk about where Rust fits across that whole journey, the trade-offs of doing media and computer vision work in a systems language, and what convinced a sports-tech company to bet on Rust for the parts that absolutely cannot fall over.
    About Veo
    Veo (Veo Technologies) is a Danish sports-tech company, headquartered in Copenhagen, that builds AI-powered cameras and a video platform for recording and analyzing matches. Instead of relying on a human camera operator, a Veo camera captures the entire pitch in panoramic video and uses computer vision to automatically follow the ball, generate highlights, and produce analysis that coaches, players, and clubs can use. What started in football has grown into a platform used by tens of thousands of teams across the world, spanning many sports, from amateur clubs to professional organizations.
    About Anders Hellerup Madsen
    Anders Hellerup Madsen is a Senior Software Engineer at Veo, where he works on embedded firmware and on the GStreamer-based media processing pipeline that runs on the Veo camera. He is also a GStreamer contributor.
    About Gorm Casper
    Gorm Casper is a Software Engineer at Veo. After many years working on the frontend, he now spends his time on the backend, writing Rust. He holds a Master's in Digital Design & Communication from the IT University of Copenhagen.
    Links From The Episode

    Official Links
    4 June 2026, 4:00 pm
  • 50 minutes 50 seconds
    Rust for Linux with Alice Ryhl and Greg Kroah-Hartman
    Hot off the press: this episode is a live recording from Rust Week in Utrecht, just two days ago. On stage with me are two people who hardly need an introduction in the Linux world: Greg Kroah-Hartman, Linux Foundation Fellow, stable kernel maintainer and an ambassador for the kernel, and Alice Ryhl, core maintainer of Tokio and one of the driving forces behind Rust for Linux at Google.
    I have to admit a bit of personal history here: I first wrote about Greg more than 20 years ago for the German online newspaper Pro-Linux. Getting to sit down with him, and with Alice, in front of a live audience to talk about how Rust is reshaping the most important piece of infrastructure on the planet, was a genuine career highlight.
    We get into the big questions: Why does Alice believe that interop, not rewrites, is how Rust wins inside Linux? How do you carefully weave in Rust while maintaining a 35-million-line C codebase? And what does it actually feel like, day to day, to write kernel code in Rust?

    “Rust is gonna save the Linux kernel.” — Greg Kroah-Hartman

    About Rust for Linux

    Rust for Linux is the project bringing the Rust programming language into the Linux kernel. After years of patches, proposals, and heated mailing list threads, Rust is now an officially supported language inside the kernel tree, no longer an experiment. The work spans everything from the build system and the kernel crate to drivers, abstractions over core subsystems and brand-new pieces of infrastructure written entirely in Rust.
    About Greg Kroah-Hartman

    Greg Kroah-Hartman is a Linux Foundation Fellow, the maintainer of the stable Linux kernel branch, and the maintainer of, among many other things, the USB subsystem, the driver core, sysfs, debugfs, kobject, TTY layer and staging tree. He has been a central figure in Linux for over two decades, has written several books about kernel development, and is convinced Rust belongs in the kernel.
    About Alice Ryhl

    Alice Ryhl is a software engineer at Google working on Android and Rust for Linux, and a core maintainer of Tokio, the asynchronous runtime that over 50% of all crates on crates.io directly depends on. Inside the kernel she works on Binder, on async abstractions, and on the bindings that allow Rust drivers to talk safely to the rest of the kernel.

    About Rust Week

    Rust Week is an annual conference organized by RustNL. The 2026 edition took place in Utrecht, the Netherlands, from May 18 to May 23. It features talks, workshops, the Rust All Hands, and expert sessions on a wide variety of topics revolving around Rust. This episode was recorded live on stage during the conference. Thanks to the Rust Week team who made this recording possible! Learn more about Rust Week on their website.
    Links From The Episode


    Official Links

    21 May 2026, 4:00 pm
  • 1 hour 21 minutes
    NLnet Labs with Arya Khanna and Martin Hoffmann
    Every time you load a website, send an email, or update an app, you're quietly relying on a handful of unglamorous services that route your packets to the right place: DNS to translate names into addresses, and BGP to figure out how to actually get there. When these systems break, or get attacked, the Internet doesn't just slow down but stops working.

    For more than 25 years, NLnet Labs has been one of the small, non-profit teams keeping that core infrastructure running. Their software, including the DNS servers NSD and Unbound, the RPKI tools Krill and Routinator, and the new DNSSEC signer Cascade, is deployed everywhere from hobbyist Pi-Hole setups to Let's Encrypt and major Internet operators. And increasingly, it's written in Rust!

    In this episode, I talk to Arya Khanna and Martin Hoffmann from NLnet Labs about what it takes to maintain critical Internet infrastructure as a small team, why they bet on Rust for new projects like the domain crate and Cascade and what the rest of us can learn from a codebase whose users include the people who keep your routes flowing.
    About NLnet Labs
    NLnet Labs is a non-profit foundation based in Amsterdam that develops open source software and open standards for the core infrastructure of the Internet. Since 1999, the small but dedicated team has built some of the most widely deployed building blocks of the modern web, including the authoritative DNS nameserver NSD, the recursive DNS resolver Unbound, and the RPKI tools Krill and Routinator, which secure global Internet routing. Their work is trusted by operators ranging from hobbyist Pi-Hole users to Let's Encrypt and major Internet service providers. In recent years, NLnet Labs has been steadily moving its new development to Rust, with projects like the domain crate and the Cascade DNSSEC signer leading the way.
    Links From The Episode
    • NSD - NLNet Labs' first project
    • lychee - A link-checker that receives funding from NLNet (not NLNet labs!)
    • unbound - A DNS server like BIND, but only for recursive queries
    • Cascade - The new DNSSEC signing solution from NLNet Labs
    • Pi-Hole - A small usecase for unbound
    • Let's Encrypt - A big user of unbound with scale and security requirements
    • Asahi Linux - Linux on Apple Silicon, mostly with Rust
    • Binder CVE - A CVE in Rust
    • LDNS - A collection of DNS functions, written in C, now in maintenance mode
    • domain - The new collection of DNS functions, written in Rust
    • tokio - The biggest shared dependency across the Rust ecosystem, first announced in 2017
    • Rust in Production: Helsing with Jon Gjengset - You can take generics too far
    • bytes - Tokio's Arc of bytes
    • Arc Welding - The other type of "fixing"
    • Alejandra González' crate dependency analysis - 46% of published crates depend directly on tokio
    • RPKI - Signing and validating IPs and routing information
    • Routinator - A RPKI validator, one of the first Rust applications in production
    • hyper - The ubiquitous HTTP crate
    • Krill - The RPKI Certificate Authority tool with "fun" shutdown code
    • Roto - Tert's scripting language, used by another NLNet Labs project, Rotonda

    Official Links
    7 May 2026, 4:00 pm
  • 1 hour 33 minutes
    Helsing with Jon Gjengset
    Jon Gjengset is one of the most recognizable names in the Rust community, the author of Rust for Rustaceans, a prolific live-streamer, and a long-time contributor to the Rust ecosystem. Today he works as a Principal Engineer at Helsing, a European defense company that has made Rust a foundational part of its engineering stack. Helsing builds safety-critical software for real-world defense applications, where correctness, performance, and reliability are non-negotiable. In this episode, Jon talks about what it means to build mission-critical systems in Rust, why Helsing bet on Rust from the start, and what lessons from his years of Rust education have shaped the way he writes and thinks about production code.
    About Helsing
    Founded in 2021, Helsing is a European defence company building AI-enabled software for some of the most demanding environments imaginable. Helsing's software runs where correctness is non-negotiable. That philosophy led them to Rust early on and they've leaned into it fully. From coordinate transforms to CRDT document stores to Protobuf package management, almost everything they build ends up being written in Rust.

    About Jon Gjengset
    Jon holds a PhD from MIT's PDOS group, where he built Noria, a high-performance streaming dataflow database, and later co-founded ReadySet to continue that work commercially. He then spent time building infrastructure at AWS, before joining Helsing as a Principal Engineer. Outside of his day job, he's been teaching Rust to the world through his livestreams and writing for years, which makes him a rare combination: someone who thinks deeply about both how to use Rust and how to explain it.
    Links From The Episode

    Official Links
    23 April 2026, 4:00 pm
  • 1 hour 15 minutes
    Cloudsmith with Cian Butler
    Rust adoption can be loud, like when companies such as Microsoft, Meta, and Google announce their use of Rust in high-profile projects. But there are countless smaller teams quietly using Rust to solve real-world problems, sometimes even without noticing. This episode tells one such story. Cian and his team at Cloudsmith have been adopting Rust in their Python monolith not because they wanted to rewrite everything in Rust, but because Rust extensions were simply best-in-class for the specific performance problems they were trying to solve in their Django application. As they had these initial successes, they gained more confidence in Rust and started using it in more and more areas of their codebase.
    About Cloudsmith
    Made with love in Belfast and trusted around the world. Cloudsmith is the fully-managed solution for controlling, securing, and distributing software artifacts. They analyze every package, container, and ML model in an organization's supply chain, allow blocking bad packages before they reach developers, and build an ironclad chain of custody.

    About Cian Butler
    Cian is a Service Reliability Engineer located in Dublin, Ireland. He has been working with Rust for 10 years and has a history of helping companies build reliable and efficient software. He has a BA in Computer Programming from Dublin City University.
    Links From The Episode
    • Lee Skillen's blog - The blog of Lee Skillen, Cloudsmith's co-founder and CTO
    • Django - Python on Rails
    • Django Mixins - Great for scaling up, not great for long-term maintenance
    • SBOM - Software Bill of Materials
    • Microservice vs Monolith - Martin Fowler's canonical explanation
    • Jaeger - "Debugger" for microservices
    • PyO3 - Rust-to-Python and Python-to-Rust FFI crate
    • orjson - Pretty fast JSON handling in Python using Rust
    • drf-orjson-renderer - Simple orjson wrapper for Django REST Framework
    • Rust in Python cryptography - Parsing complex data formats is just safer in Rust!
    • jsonschema-py - jsonschema in Python with Rust, mentioned in the PyO3 docs
    • WSGI - Python's standard for HTTP server interfaces
    • uWSGI - A application server providing a WSGI interface
    • rustimport - Simply import Rust files as modules in Python, great for prototyping
    • granian - WSGI application server written in Rust with tokio and hyper
    • hyper - HTTP parsing and serialization library for Rust
    • HAProxy - Feature rich reverse proxy with good request queue support
    • nginx - Very common reverse proxy with very nice and readable config
    • locust - Fantastic load-test tool with configuration in Python
    • goose - Locust, but in Rust
    • Podman - Daemonless container engine
    • Docker - Container platform
    • buildx - Docker CLI plugin for extended build capabilities with BuildKit
    • OrbStack - Faster Docker for Desktop alternative
    • Rust in Production: curl with Daniel Stenberg - Talking about hyper's strictness being at odds with curl's permissive design
    • axum - Ergonomic and modular web framework for Rust
    • rocket - Web framework for Rust

    Official Links
    9 April 2026, 3:00 pm
  • 58 minutes 49 seconds
    Gama Space with Sebastian Scholz
    Space exploration demands software that is reliable, efficient, and able to operate in the harshest environments imaginable. When a spacecraft deploys a solar sail millions of kilometers from Earth, there's no room for memory bugs, race conditions, or software failures. This is where Rust's robustness guarantees become mission-critical.
    In this episode, we speak with Sebastian Scholz, an engineer at Gama Space, a French company pioneering solar sail and drag sail technology for spacecraft propulsion and deorbiting. We explore how Rust is being used in aerospace applications, the unique challenges of developing software for space systems, and what it takes to build reliable embedded systems that operate beyond Earth's atmosphere.

    About Gama Space
    Gama Space is a French aerospace company founded in 2020 and headquartered in Ivry-sur-Seine, France. The company develops space propulsion and orbital technologies with a mission to keep space accessible. Their two main product lines are solar sails for deep space exploration using the sun's infinite energy, and drag sails—the most effective way to deorbit satellites and combat space debris. After just two years of R&D, Gama successfully launched their satellite on a SpaceX Falcon 9. The Gama Alpha mission is a 6U cubesat weighing just 11 kilograms that deploys a large 73.3m² sail. With 48 employees, Gama is at the forefront of making space exploration more sustainable and accessible.
    About Sebastian Scholz
    Sebastian Scholz is an engineer at Gama Space, where he works on developing software systems for spacecraft propulsion technology. His work involves building reliable, safety-critical embedded systems that must operate flawlessly in the extreme conditions of space. Sebastian brings expertise in systems programming and embedded development to one of the most demanding environments for software engineering.
    Links From The Episode
    • GAMA-ALPHA - The demonstration satellite launched in January 2023
    • Ada - Safety-focused programming language used in aerospace
    • probe-rs - Embedded debugging toolkit for Rust
    • hyper - Fast and correct HTTP implementation for Rust
    • Flutter - Google's UI toolkit for cross-platform development
    • UART - Very common low level communication protocol
    • Hamming Codes - Error correction used to correct bit flips
    • Rexus/Bexus - European project for sub-orbital experiments by students
    • Embassy - The EMBedded ASsYnchronous framework
    • CSP - The Cubesat Space Protocol
    • std::num::NonZero - A number in Rust that can't be 0
    • std::ffi::CString - A null-byte terminated String
    • Rust in Production: KSAT - Our episode with Vegard about using Rust for Ground Station operations
    • Rust in Production: Oxide - Our episode with Steve, mentioning Hubris
    • Hubris - Oxide's embedded operating system
    • ZeroCopy - Transmute data in-place without allocations
    • std::mem::transmute - Unsafe function to treat a memory section as a different type than before

    Official Links
    22 January 2026, 4:00 pm
  • 1 hour 3 minutes
    Radar with Jeff Kao
    Radar processes billions of location events daily, powering geofencing and location APIs for companies like Uber, Lyft, and thousands of other apps. When their existing infrastructure started hitting performance and cost limits, they built HorizonDB, a specialized database which replaced both Elasticsearch and MongoDB with a custom single binary written in Rust and backed by RocksDB.

    In this episode, we dive deep into the technical journey from prototype to production. We talk about RocksDB internals, finite-state transducers, the intricacies of geospatial indexing with Hilbert curves, and why Rust's type system and performance characteristics made it the perfect choice for rewriting critical infrastructure that processes location data at massive scale.

    About Radar
    Radar is the leading geofencing and location platform, trusted by companies like Uber, Lyft, and thousands of apps to power location-based experiences. Processing billions of location events daily, Radar provides geofencing APIs, geocoding, and location tracking that enables developers to build powerful location-aware applications. Their infrastructure handles massive scale with a focus on accuracy, performance, and reliability.
    About Jeff Kao
    Jeff Kao is a Staff Engineer at Radar, where he led the development of HorizonDB, Radar's geospatial database written in Rust. His work replaced Elasticsearch and MongoDB with a custom Rust stack built on RocksDB, achieving dramatic improvements in performance and cost efficiency. Jeff has deep experience with geospatial systems and previously open-sourced Node.js TypeScript bindings for Google's S2 library. He holds a degree from the University of Waterloo.
    Links From The Episode

    Official Links
    8 January 2026, 4:00 pm
  • More Episodes? Get the App