TopPodcast.com
Menu
  • Home
  • Top Charts
  • Top Networks
  • Top Apps
  • Top Independents
  • Top Podfluencers
  • Top Picks
    • Top Business Podcasts
    • Top True Crime Podcasts
    • Top Finance Podcasts
    • Top Comedy Podcasts
    • Top Music Podcasts
    • Top Womens Podcasts
    • Top Kids Podcasts
    • Top Sports Podcasts
    • Top News Podcasts
    • Top Tech Podcasts
    • Top Crypto Podcasts
    • Top Entrepreneurial Podcasts
    • Top Fantasy Sports Podcasts
    • Top Political Podcasts
    • Top Science Podcasts
    • Top Self Help Podcasts
    • Top Sports Betting Podcasts
    • Top Stocks Podcasts
  • Podcast News
  • About Us
  • Podcast Advertising
  • Contact
Not in our directory?
Add Show Here
Podcast Equipment
Center

toppodcastlogoOur TOPPODCAST Picks

  • Comedy
  • Crypto
  • Sports
  • News
  • Politics
  • True Crime
  • Business
  • Finance

Follow Us

toppodcastlogoStay Connected

    View Top 200 Chart
    Back to Rankings Page
    Technology

    Rust in Production

    This is “Rust in Production”, a podcast about companies who use Rust to shape the future of infrastructure. We follow their journey in pursuit of more reliable and efficient software as they solve some of the most challenging technical problems in the world.

    Each episode dives deep into real-world applications of Rust, showcasing how this powerful systems programming language is revolutionizing the way we build and maintain critical infrastructure. From startups to tech giants, we explore the diverse landscape of organizations leveraging Rust’s unique features to create safer, faster, and more scalable systems.

    Our guests share their experiences, challenges, and triumphs in adopting Rust for production environments. Listen in as we discuss topics such as concurrent programming, memory safety, performance optimization, and how Rust’s ownership model contributes to building robust software systems. Whether you’re a seasoned Rust developer, an infrastructure engineer, or a tech leader considering Rust for your next project, “Rust in Production” offers valuable insights and practical knowledge.

    Release Schedule

    “Rust in Production” releases new episodes every other Thursday at 4 PM UTC. Our podcast is structured into seasons, each featuring a diverse range of companies and experts in the Rust ecosystem. Recent episodes have included:

    – Season 2: Interviews with representatives from System76, Fusion Engineering, OxidOS, Matic, Thunderbird, AMP, and curl.
    – Season 1: Conversations with leaders from Sentry, Tweede Golf, Arroyo, Apollo, PubNub, and InfluxData.

    What You’ll Learn

    – Real-world case studies of Rust implementation in production environments
    – Insights into how companies overcome technical challenges using Rust
    – Best practices for adopting Rust in various infrastructure contexts
    – The impact of Rust on software reliability, efficiency, and scalability
    – Future trends in systems programming and infrastructure development

    Join us as we uncover the latest trends in Rust development, explore best practices for using Rust in production, and examine how this language is addressing some of the most pressing issues in modern software engineering. From web services and databases to embedded systems and cloud infrastructure, we cover the full spectrum of Rust’s impact on the tech industry.

    Advertise

    Copyright: © Matthias Endler

    • Apple Podcasts
    • Google Play
    • Spotify
    Latest Episodes:
    1Password with Andrew Burkhart Jun 26, 2025
    Show notes Handling secrets is extremely hard. You have to keep them safe (obviously), while at the same time you need to integrate with a ton of different systems and always provide a great user-experience, because otherwise people will just find a way around your system. When talking to peers, a lot of people mention 1Password as a company that nailed this balance.
    In today's episode, I talk to Andrew about how 1Password uses Rust to build critical systems that must never fail, how Rust helps them handle secrets for millions of users, and the lessons they learned when adopting Rust in their stack.
    About 1Password
    1Password is a password manager that helps users securely store and manage their passwords, credit card information, and other sensitive data. It provides a user-friendly interface and strong security features to protect users' secrets across multiple devices.
    About Andrew Burkhart
    Andrew is a Senior Rust Developer at 1Password in the Product Foundations org, on the Frameworks team and specifically on the Core Platform squad handling the asynchronous frameworks other developers use to build features (i.e. requests into the Rust core from the Native clients, data sync, etc.). He specifically specialized in that synchronization process, getting data federated from cloud to clients to native apps and back.
    Links From The Episode
    • Backend for Frontend Pattern - Architectural pattern for creating dedicated backends for specific frontends
    • typeshare - Generate types for multiple languages from Rust code
    • zeroizing-alloc - 1Password's minimal secure heap zero-on-free implementation for Rust
    • arboard - Cross-platform clipboard manager written in Rust
    • passkey-rs - Pure Rust implementation of the WebAuthn Passkey specification
    • WebAssembly (WASM) - Binary instruction format for portable execution across platforms
    • tokio - The de facto standard async runtime for Rust
    • Clippy - A collection of lints to catch common mistakes in Rust
    • cargo-deny - Cargo plugin for linting dependencies, licenses, and security advisories
    • Nix - Purely functional package manager for reproducible builds
    • Nix Flakes - Experimental feature for hermetic, reproducible Nix builds
    • direnv - Load and unload environment variables based on current directory
    • ACM: Spotify Guilds - A study into Spotify's Agile Model's Guilds
    • axum - Ergonomic and modular web framework built on tokio and tower
    • tower - Library for building robust networking clients and servers
    • tracing - Application-level tracing framework for async-aware diagnostics
    • rusqlite - Ergonomic wrapper for SQLite in Rust
    • mockall - Powerful mock object library for Rust
    • pretty_assertions - Better assertion macros with colored diff output
    • neon - Library for writing native Node.js modules in Rust
    • nom-supreme - Parser combinator additions and utilities for nom
    • crane - Nix library for building Cargo projects
    • Rust in Production: Zed - High-performance code editor built in Rust
    • tokio-console - Debugger for async Rust programs using tokio
    • Rust Atomics and Locks by Mara Bos - Free online book about low-level concurrency in Rust
    • The Rust Programming Language (Brown University Edition) - Interactive version of the Rust Book with quizzes
    • Rustlings - Small exercises to get you used to reading and writing Rust code

    Official Links
    • 1Password
    • Andrew on GitHub
    • Andrew on LinkedIn
    Tembo with Adam Hendel Jun 12, 2025
    Show notes Recently I was in need of a simple job queue for a Rust project. I already had Postgres in place and wondered if I could reuse it for this purpose. I found Tembo, a simple job queue written in Rust that uses Postgres as a backend. It fit the bill perfectly.
    In today's episode, I talk to Adam Hendel, the founding engineer of Tembo, about their project, PGMQ, and how it came to be. We discuss the design decisions behind job queues, interfacing from Rust to Postgres, and the engineering decisions that went into building the extension.
    It was delightful to hear that you could build all of this yourself, but that you would probably just waste your time doing so and would come up with the same design decisions as Adam and the team.
    About Tembo
    Tembo builds developer tools that help teams build and ship software faster. Their first product, PGMQ, was created to solve the problem of job queues in a simple and efficient way, leveraging the power of Postgres. They since made a pivot to focus on AI-driven code assistance, but PGMQ can be used independently and is available as an open-source project.
    About Adam Hendel
    Adam Hendel is the founding engineer at Tembo, where he has been instrumental in developing PGMQ and other tools like pg_vectorize. He has since moved on to work on his own startup, but remains involved with the PGMQ project.
    Links From The Episode
    • PostgreSQL - Super flexible ~40 year old relational database that just works
    • R - Statistical Programming Language
    • pgrx - Extend Postgres with Rust
    • Postgres Docs: PL/pgSQL - Scripting with Procedural Language in PostgreSQL
    • Postgres Docs: SPI - The Postgres Server Programming Interface
    • pgmq - A lightweight message queue extension, initially written in Rust
    • Tembo Blog: Introducing PGMQ - a blog post about the project
    • sqlx - All of the great things of an ORM, without all of the bad things of an ORM
    • tokio - The de facto standard async runtime for Rust
    • AWS SQS - Amazon Web Services Simple Queue Service
    • Postgres Docs: LISTEN - The native Postgres sub part of of pubsub
    • Postgres Docs: NOTIFY - The native Postgres pub part of of pubsub
    • tokio-stream - Tokio utility for asynchronous series of values
    • Postgres Docs: Full Text Search - Postgres included FTS capabilities
    • pgvector - The standard extension for vector/AI workloads in Postgres
    • pg_vectorize - Automatically create embeddings for use with pgvector
    • Python Standard Library: None - A type, but not an enum
    • Rust in Production: Astral with Charlie Marsh - Massively improving Python day 1 experience
    • Hugging Face candle - Use ML models in Rust

    Official Links
    • Tembo
    • Adam on LinkedIn
    • Adam on GitHub
    Rust with Niko Matsakis May 29, 2025
    Show notes Few developers have been as influential to my career as Niko Matsakis. Of course he is a world-class engineer with a PhD from ETH Zürich, a Rust core maintainer who has been working on the language for way more than a decade, and a Senior Principal Engineer at AWS. But more importantly, he is an empathetic human and an exceptional communicator.
    I've personally been waiting for one year to get him on the show and steal one hour of his precious time. Now, finally, I got my chance at live recording at Rust Week 2025. The result is everything I hoped for: a trip down memory lane which takes us back to the early days of Rust, an honest and personal look at Rust's strengths and weaknesses, and a glimpse into the future of the language. All of that packed with insightful anecdotes based on Niko's decades of experience. If you like Rust, you will enjoy this episode.
    About Rust
    Rust is the language which brought us all together. What started as a side-project of Graydon Hoare, a single developer at Mozilla, has grown into a worldwide community of hobbyists, professionals, and companies which all share the same goal: to build better, safer software paired with great ergonomics and performance.
    About Niko Matsakis
    Niko is a long-time Rust core team member, having joined the project in 2012. He was and still is part of the team which designed and implemented Rust's borrow checker, which is the language's most important feature. He has been a voice of reason and a guiding light for many of us, including myself. His insightful talks and blog posts have helped countless developers to see the language and its goals in a new light.
    Special Thanks
    Thanks to RustNL, the organizers of Rust Week 2025 for inviting Simon and me to record this episode live. They did a fantastic job organizing the event, and it was an honor to be part of it.
    Proudly Supported by CodeCrafters

    CodeCrafters helps you become proficient in Rust by building real-world, production-grade projects. Learn hands-on by creating your own shell, HTTP server, Redis, Kafka, Git, SQLite, or DNS service from scratch. Start for free today and enjoy 40% off any paid plan by using this link.
    Links From The Episode
    • RustWeek 2025 - Rust conference in Utrecht where we recorded this live episode
    • DataPower - Niko's employer before working on Rust
    • XSLT - Language to transform arbitrarily shaped XML into different arbitrary shapes
    • ETH Zürich - Niko's Alma Mater
    • Mozilla - Niko's first employer while working on Rust
    • rustboot - Rust's first compiler written in OCaml
    • Don Quixote - Personification of impractical idealism, just like Rust was in the beginning
    • Steve Klabnik's FOSDEM talk - Coining "The Graydon years", Slides, Recording of the same talk for ACM
    • Rust 0.2 Keywords - ret for return, cont for continue
    • Boxes in Rust 0.8 - ~T and @T as syntax features instead of Box<T> and Rc<T>
    • Green Threads - Like OS threads, but greener!
    • std::threads - Not green, just part of the standard library
    • std::rc::Rc - The @T of std
    • std::boxed::Box - The ~T of std with some special compiler sauce
    • std::sync::Arc - Thread safe Rc
    • pyo3::Py - A pointer type in a different library!
    • The Rust Book: Understanding Ownership - Ownership and borrowing are the first third of "the simple core of Rust"
    • The Rust Book: Using Trait Objects - Trait-based dispatch being the second part of "the simple core of Rust"
    • std::marker::Send - A trait without even a method to dispatch, aptly placed in the marker module
    • std::marker::Sync - Another example of a marker trait
    • Linear Type Systems - Foundational research topic for borrowing in Rust
    • regex - "Real stuff" built in Rust
    • rayon - Turning iterators into parallel processing
    • Tokio Async Runtime - An entire async ecosystem as a perfomant library
    • Comment on RFC 2394 - The beginning of the await x / x.await discussion?
    • Alex Crichton - Rust compiler, wasm, and lang-advisors team member
    • cramertj - Rust lang-advisors and libs-contributors team member
    • withoutboats - Rust team alumni
    • Carl Lerche - tokio maintainer
    • aturon - Rust team alumni
    • ALGOL 60 - Doesn't look like C
    • try blocks - Do we need a postfix match operator for this?
    • Rust Blog: Announcing Rust 1.31 and Rust 2018 - A watershed moment for Rust
    • Non-lexical lifetimes - Included in 1.31 and Rust 2018
    • Santiago Pastorino - Rust compiler contributor, worked on non-lexical lifetimes
    • Makefile Example - "We don't need cargo, Make is fine"
    • Rust Blog: Laying the foundation for Rust's future - Mozilla's parting gift to Rust?
    • Tyler Mandry - Rust lang team co-lead with Niko
    • Josh Triplett - Rust lang, cargo, and libs team member
    • Amazon S3 Express One Zone storage class - Super low latency S3, written in Rust
    • Amazon Aurora DSQL - Serverless SQL, an AWS project that started 100% in JVM and finished 100% Rust
    • Just make it scale: An Aurora DSQL story - Blog post detailing the Aurora DSQL Rust rewrite
    • Rust in 2025: Targeting foundational software - Niko's vision for Rust
    • Be excellent to each other - Party on dudes!

    Official Links
    • Rust Language
    • Rust Foundation
    • Niko Matsakis' Homepage
    • Niko Matsakis on GitHub
    uv with Charlie Marsh May 15, 2025
    Show notes Up until a few years ago, Python tooling was a nightmare: basic tasks like installing packages or managing Python versions was a pain. The tools were brittle and did not work well together.
    Then, suddenly, we saw a renaissance of new ideas in the Python ecosystem. It started with Poetry and pipx and continued with tooling written in Rust like rye, which later got incorporated into Astral.Astral in particular contributed a very important piece to the puzzle: uv -- an extremely fast Python package and project manager that supersedes all previous attempts; For example, it is 10x-100x faster than pip.
    In this episode I talk to Charlie Marsh, the Founder and CEO of Astral. We talk about Astral's mission and how Rust plays an important role in it.
    About Astral
    Astral is a company that builds tools for Python developers. What sounds simple is actually a very complex problem: Python's ecosystem is huge, but fragmented and often incompatible. Astral’s mission is to make the Python ecosystem more productive by building high-performance developer tools, starting with Ruff. In their words: "Fast, unified, futuristic."
    About Charlie Marsh
    Charlie is a long-time open source developer and entrepreneur. He has an impressive CV, graduating with highest honors from Princeton University. After that, he worked at Khan Academy and others before eventually founding Astral in '22. Charlie is an engaging speaker and a great communicator.
    Proudly Supported by CodeCrafters

    CodeCrafters helps you become proficient in Rust by building real-world, production-grade projects. Learn hands-on by creating your own shell, HTTP server, Redis, Kafka, Git, SQLite, or DNS service from scratch. Start for free today and enjoy 40% off any paid plan by using this link.
    Links From The Episode
    • ruff - Python static linter and formatter written in Rust
    • uv - Python package and project manager written in Rust
    • rustfmt - Rust code formatter
    • clippy - Linter for Rust code
    • The Rust Programming Language: Cargo Workspaces - The Rust Book's chapter on workspaces
    • pip - Package Installer for Python
    • pip documentation: Requirements File Format - A description of the format of requirements.txt, including a list of embedded CLI options
    • uv's CI - Build scripts for many different platforms
    • jemalloc - Alternative memory allocator
    • zlib-ng - Next Generation zlib implementation in C
    • reqwest - An easy and powerful Rust HTTP Client
    • zlib-rs - Pure Rust implementation of zlib
    • XCode Instruments - Native macOS performance profiler
    • CodSpeed - Continuous benchmarking in CI
    • hyperfine - "macro benchmarking" tool, coincidentally written in Rust
    • samply - Sampling based profiler written in Rust
    • cargo flamegraph - Cargo profiling plugin
    • tokio - Asynchronous runtime for Rust
    • curl-rust - Network API used in cargo
    • tar-rs - Sync tar crate
    • async-tar - Async tar crate based on the async_std runtime
    • tokio-tar - Async tar crate based on tokio
    • astral-tokio-tar - Async tar crate based on tokio, maintained by Astral
    • RustPython - Python interpreter written in Rust
    • lalrpop - The parser generator used by RustPython
    • Charlie's EuroRust 2024 Talk - Mentions the version number parser at 18:45
    • ripgrep - Andrew Gallant's idiomatic Rust project, which also happens to be a very fast CLI file search tool

    Official Links
    • Astral
    • Charlie's Website
    • Charlie on GitHub
    Svix with Tom Hacohen May 01, 2025
    Show notes We don't usually think much about Webhooks -- at least I don't. It's just web requests after all, right? In reality, there is a lot of complexity behind routing webhook requests through the internet. What if a webhook request gets lost? How do you know it was received in the first place? Can it be a security issue if a webhook gets handled twice? (Spoiler alert: yes)
    Today I sit down with Tom from Svix to talk about what it takes to build an enterprise-ready webhook service. Of course it's written in Rust.
    About Svix
    Svix provides webhooks as a service. They build a secure, reliable, and scalable webhook sending and receiving system using Rust. The company handles billions of webhooks a year, so they know a thing or two about the complexities involved.
    About Tom Hacohen
    Tom is an entrepreneur and open source maintainer from Tel-Aviv (Israel) and based in the US. He's worked with people from all around the globe (excluding Antarctica). Prior to Svix, he worked as an Engineer at Samsung's Open Source Group on the Enlightenment Foundation Libraries (EFL) that are used by the Samsung backed Tizen mobile operating system.
    Proudly Supported by CodeCrafters

    CodeCrafters helps you become proficient in Rust by building real-world, production-grade projects. Learn hands-on by creating your own shell, HTTP server, Redis, Kafka, Git, SQLite, or DNS service from scratch. Start for free today and enjoy 40% off any paid plan by using this link.
    Links From The Episode
    • Microsoft IIS - Microsoft's HTTP server
    • Elixir - General purpose programming language based on the Erlang VM
    • Go Spec: Exported Identifiers - How to mark interface functions as public
    • Bob Nystrom: What Color is Your Function? - A good explanation of colored functions and the problems they introduce
    • jemallocator - Use jemalloc as the global allocator in Rust
    • serde-json - The go-to solution for parsing JSON in Rust
    • serde - High-level serilization and deserialization interface crate
    • axum - The defacto async web server crate
    • seaorm - SeaORM is a relational ORM to help you build web services in Rust
    • redis-rs - Redis library for rust
    • aide - OpenAPI generation from axum code
    • dropshot - Oxide API framework that generates OpenAPI spec
    • KSUID - A pure-Rust K sorted UID implementation
    • omniqueue - A queue abstraction layer for Rust
    • Python GIL - The Global Interpreter Lock Python wiki entry
    • Svix Blog: Robust APIs Through OpenAPI Generation - How to build stable APIs through schema generation and reviews

    Official Links
    • Svix
    • Tom Hacohen's Blog
    • Tom on GitHub
    • Tom on Mastodon
    Microsoft with Victor Ciura Apr 17, 2025
    Show notes Victor Ciura is a veteran C++ developer who worked on Visual C++ and the Clang Power Tools. In this first episode of season 4, we talk to him about large-scale Rust adoption at Microsoft.
    Victor works as a Principal Engineer on the Rust team in Microsoft's Developer Division, building the compiler toolchain and libraries needed for the broader Rust efforts across the organization. He is a regular speaker at conferences like CPPCon and also spoke at EuroRust 2024.
    We talk about Microsoft's first steps with Rust, widespread implementation across key products and services, and Hyrum's Law.
    About Microsoft
    Microsoft is a company that needs no further introduction. From Windows to Azure, Microsoft has a wide range of products and services. A while ago, Microsoft started an initiative to bring Rust into core parts of their ecosystem.
    About Victor Ciura
    Victor is a well-known C++ expert leading Microsoft's Rust adoption efforts. His work focuses on ensuring Rust interoperates with existing C++ codebases and integrating the Rust compiler and toolchain into the Microsoft ecosystem.
    Proudly Supported by CodeCrafters

    CodeCrafters helps you become proficient in Rust by building real-world, production-grade projects. Learn hands-on by creating your own shell, HTTP server, Redis, Kafka, Git, SQLite, or DNS service from scratch. Start for free today and enjoy 40% off any paid plan by using this link.
    Links From The Episode
    • Victor's EuroRust 2024 Talk - Victor's presentation on Microsoft's Rust adoption journey
    • TockOS - Embedded operating system written in Rust
    • Google's Fuchsia - Google's open-source operating system with Rust components
    • Mu - Open Source UEFI implementation in Rust
    • Caliptra - Hardware Root of Trust implementation
    • Azure Cloud HSM - Hardware Security Module using Rust
    • HyperV - Microsoft's Hypervisor
    • Google Security Study on using Rust - Research on memory safety improvements
    • COM - The "grandfather of all inter-op technology"
    • Direct Write Core - Microsoft's text rendering implementation in Rust
    • Hyrum's Law - Your users will end up depending on all of your observable internal behavior
    • LWN Article: Rust/Linux fallout - Discussion about Rust integration into the Linux kernel
    • clippy - Static Analyzer for Rust code
    • ABI Resilience - Victor's talk at Rust Nation UK
    • MSBuild - Microsoft's build tool
    • Miri - An interpreter for Rust's mid-level intermediate representation

    Official Links
    • Microsoft Rust Documentation
    • Victor Ciura's Blog
    • Victor Ciura on Bluesky
    • Victor Ciura on Mastodon
    • Microsoft Rust Articles
    Season 3 Finale Feb 06, 2025
    Show notes You know the drill by now. It's time for another recap!
    Sit back, get a warm beverage and look back at the highlights of Season 3 with us.
    We've been at this for a while now (three seasons, one year, and 24 episodes to be exact). We had guests from a wide range of industries: from automotive to CAD software, and from developer tooling to systems programming.
    Our focus this time around was on the technical details of Rust in production, especially integration of Rust into existing codebases and ecosystem deep dives. Thanks to everyone who participated in the survey last season, which helped us dial in our content. Let us know if we hit the mark or missed it!
    For the future, we hope to present an even more diverse set of guests and topics. If you have any suggestions, please reach out!
    We'll be back in April. In the meantime, check out our dedicated learn page for additional content about Rust adoption.
    Proudly Supported by CodeCrafters

    CodeCrafters helps you become proficient in Rust by building real-world, production-grade projects. Learn hands-on by creating your own shell, HTTP server, Redis, Kafka, Git, SQLite, or DNS service from scratch. Start for free today and enjoy 40% off any paid plan by using this link.
    Links from the Episode
    • ThoughtWorks Tech Radar Volume 31, October 2024 - Ranks Rust as well-established in systems programming
    • Chrome Rust Integration - Chrome team's integration of Rust into browser build system
    • Google's Director of Engineering, Lars Bergstrom, on Rust - "Rust teams are twice as productive as teams using C++"
    • Android memory vulnerabilities drop by 52% after switching to Rust - Google's adoption of Rust
    • Bevy - Rust game engine with entity component system
    • LogLog Games - Leaving Rust for gamedev - Thoughtful article about why LogLog Games no longer uses Rust for game development
    • TinyGlade - Game fully written in Rust, available on Steam
    • One Of The Rust Linux Kernel Maintainers Steps Down - Cites "Nontechnical Nonsense" - Discussion about Rust adoption in the Linux kernel
    • curl removing hyper support - Discussion about curl removing hyper support
    • Daniel Stenberg on the 'Rust in Production' Podcast - The curl maintainer talks about Rust adoption
    • Hyper - HTTP implementation in Rust, previously used in curl
    • RusTLS - TLS implementation still used in curl
    • Rust Foundation Members - List of Rust Foundation members
    • crates.io - Rust package registry, crossed 100 billion downloads
    • Rust subreddit - Community forum for Rust (332,529 readers)
    • C++ subreddit - Community forum for C++ (307,865 readers)
    • serde - Serialization framework for Rust
    • clap - Command line argument parser for Rust
    • Adblock Rust - First adblock engine that compiles to native code
    • probe-rs - Improves developer experience for embedded environments
    • RustAsia - Conference initiative for Asian Rust community
    • Tokio - Winner of the "runtime wars", primary async runtime
    • async-std - Alternative async runtime, now effectively inactive
    • RustRover - IDE by JetBrains with Rust support
    • Polars - Data manipulation library in Rust
    • uv - Python packaging tool by Astral
    • GitButler - New version control tool written in Rust
    • jj - Alternative version control system in Rust
    • Zed - New code editor written in Rust
    • Ferrocene - Enterprise Rust support initiative
    • Rust 2024 Edition - Set to release February 20th, 2025
    • Rust Week - Upcoming conference with available tickets
    • Windows API Crate - Official Microsoft crate for Windows API
    • Rust Conferences 2025 - Calendar of Rust events

    About Us
    • Simon Brüggen (M3t0r) on GitHub
    • Simon Brüggen (M3t0r) on Mastodon
    • Matthias Endler on Mastodon
    • About corrode Rust Consulting
    • 'Rust in Production' Podcast on Apple
    • 'Rust in Production' Podcast on Spotify

    All Episodes of Season 3

    If you missed any of the previous episodes, now is a great time to catch up:
    • Episode 1: Zed with Conrad Irwin
    • Episode 2: InfinyOn with Deb Roy Chowdhury
    • Episode 3: Oxide with Steve Klabnik
    • Episode 4: GitButler with Scott Chacon and Kiril Videlov
    • Episode 5: Zoo with Jessie Frazelle
    • Episode 6: Holiday Episode with yours truly
    • Episode 7: Brave with Anton Lazarev
    • Episode 8: Volvo Cars with Julius Gustavsson

    Credits
    Podcast production by Simon Brüggen (M3t0r).
    We would like to thank the guests for their time and insights. We would also like to thank you, the listener for your support and feedback. Hosting and producing a podcast is a lot of work, but it's worth it when we hear from you. Here's to another great season!
    Volvo with Julius Gustavsson Jan 23, 2025
    Show notes The car industry is not known for its rapid adoption of new technologies. Therefore, it's even more exciting to see a company like Volvo Cars embracing Rust for core components of their software stack.
    We talked to Julius Gustavsson, System Architect at Volvo Cars, about the use of Rust for their Electronic Control Units (ECUs) in Volvo's EX90 and Polestar 3 models and how they are building a Rust ecosystem within the company.
    About Volvo
    Volvo Cars is a Swedish premium car manufacturer founded in 1927. The company is known for its focus on robustness, safety, and sustainability. Its headquarters are in Gothenburg, Sweden, and it has manufacturing plants in Sweden, Belgium, China, and the United States.
    About Julius Gustavsson
    Prior to Volvo Cars, Julis worked at Ericsson, among other companies. His background is in embedded systems and software development. His master's thesis was about System-on-Chip (SoC) design.
    Proudly Supported by CodeCrafters

    CodeCrafters helps you become proficient in Rust by building real-world, production-grade projects. Learn hands-on by creating your own shell, HTTP server, Redis, Kafka, Git, SQLite, or DNS service from scratch. Start for free today and enjoy 40% off any paid plan by using this link.
    Links From The Episode (In Chronological Order)
    • SPA2 - The automotive platform using Rust
    • ASIL - Automotive Safety Standard
    • Ferrocene - Rust toolchain for critical systems
    • Rust 2018 - First edition with support for ARM in stable
    • Grepit - Contractors who worked with Volvo
    • UDS - Universal automotive diagnostic standard
    • CBOR - JSON, but binary
    • serde - Super awesome serialization/deserialization crate
    • probe-rs - Flashing and debugging embedded chips as simple as uploading PHP files to a webserver
    • SBOM - Ingredients of your compiled binary
    • Rust in Production: cURL with Daniel Stenberg - Find cURL in an SBOM near you!
    • Zuul CI - CI tool with speculative merging support
    • Robot Framework - BDD testing for hardware
    • clippy::pedantic - clippy on hard mode
    • heapless - When you want a heap but only have a stack
    • AUTOSAR Classic - automotive framework with Rust support
    • Volvo tech blog: Why Rust is actually good for your car
    • Rust is rolling off the Volvo assembly line - Tweede Golf - Blog post about Volvo Cars using Rust
    • Safety Critical Rust Consortium - Aiming to make Rust a fully viable alternative for safety critical software

    Official Links
    • Volvo Cars
    • Julius Gustavsson on LinkedIn
    • Julius Gustavsson on Mastodon
    Brave with Anton Lazarev Jan 09, 2025
    Show notes Web browsers today face increasing demands for both performance and privacy. At Brave, they're tackling both challenges head-on with their Rust-based ad-blocking engine. This isn't just about blocking ads – it's about doing so with minimal performance impact while maintaining compatibility with existing filter lists and adapting to evolving web technologies.
    Today we're joined by Anton Lazarev, Senior Software Engineer at Brave, to discuss how they're using Rust to build a high-performance ad-blocker, the challenges of working within browser constraints, and how they're pushing the boundaries of what's possible in modern web privacy.
    About Brave
    Brave is a privacy-focused web browser that blocks ads and trackers by default. It's built on top of Chromium, with additional privacy features like the ability to earn cryptocurrency by viewing privacy-respecting ads. Brave has been an early adopter of Rust, using it to build their ad-blocking engine and other core features.
    About Anton Lazarev
    Anton Lazarev is a Senior Software Engineer at Brave, where he works on the browser's core privacy features. In his free time, Anton enjoys working on like his fully open-source and Rust-based, customizable split keyboard.
    Proudly Supported by CodeCrafters

    CodeCrafters helps you become proficient in Rust by building real-world, production-grade projects. Learn hands-on by creating your own shell, HTTP server, Redis, Kafka, Git, SQLite, or DNS service from scratch. Start for free today and enjoy 40% off any paid plan by using this link.
    Links From The Episode (In Chronological Order)
    • VST - Audio plugin standard
    • Azul - Early Rust UI library
    • Rust subreddit "Who's Hiring" - Looking for a Rust job?
    • XPath - Alternative to CSS style selectors
    • CXX - C/C++ Rust Interop crate
    • CNAME cloaking - Technique for disguising tracking domains
    • Manifest V3 - New extension platform specification
    • uBlock Origin - Popular content blocker
    • adblock-rust - Brave's adblock engine written in Rust
    • Public Suffix List - Explains what a "suffix" is compared to a TLD
    • Servo2 - Next generation browser engine
    • Ladybird - Browser project
    • Swift supported compile targets
    • Matthias: "The Dying Web"
    • GN - Old Chromium build system
    • GNRT - New Chromium build system: GN from Rust third_party (pronounced "generate")
    • Bazel - Google's build system
    • Ninja - Small build system focusing on speed
    • Angelfish browser
    • QuteBrowser - Keyboard-focused browser
    • Privaxy - Privacy proxy using adblock-rust
    • Readable - Matthias' attempt to make the web readable
    • Anton's Keyboard - Custom keyboard setup

    Official Links
    • Brave
    • Brave Browser
    • Brave Search
    • Anton Lazarev on GitHub
    • Anton Lazarev on Mastodon
    Holiday Special Dec 26, 2024
    Show notes While we try not to get too sentimental, celebrating one year of 'Rust in Production' alongside the holiday season feels like a perfect occasion to reflect. For this special episode of the podcast, we've gathered heartfelt messages from our guests to the Rust community.
    There are two common themes that run through these messages:
    • The importance of writing simple, approachable Rust code to help flatten the learning curve for newcomers
    • Their gratitude for the vibrant ecosystem and the wealth of available crates
    As we look ahead to the Rust 2024 edition, we're excited about what's to come. Thank you for being part of this journey with us, and here's to a great start to 2025! May the new year bring us all faster compile times, gentler learning curves, and, if we get lucky, let-chains on stable Rust.
    Proudly Supported by CodeCrafters

    CodeCrafters helps you become proficient in Rust by building real-world, production-grade projects. Learn hands-on by creating your own shell, HTTP server, Redis, Kafka, Git, SQLite, or DNS service from scratch. Start for free today and enjoy 40% off any paid plan by using this link.
    Previous 1 2 3 4 5 6 Next

    Related Podcasts

    Reply All

    1

    Reply All Games & Hobbies
    Inside VR & AR

    2

    Inside VR & AR Gadgets
    Note to Self

    3

    Note to Self News
    BrainStuff

    4

    BrainStuff Natural Sciences
    This Week in Tech (Audio)

    5

    This Week in Tech (Audio) News
    Hands-On Tech (Audio)

    6

    Hands-On Tech (Audio) Technology
    footer-logo

    Contact Us

    Toll Free: 844-670-7747

    Links

    • Home
    • Top Charts
    • Networks
    • Apps
    • Independents Podcasts
    • Podcast Advertising
    • Podcast News
    • Contact Us
    • About Us
    • Analytics & Insights

    Stay Connected

      Privacy, Terms of Use & Our Code of Ethics Protecting Content Creators Copyrights