Rust in Production

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.

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.

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.

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.

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.

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.

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:

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.

Think about this: software engineers have modern code editors, parallel processing, continuous integration, and countless tools that make their work efficient. But hardware engineers? They're often working with single-threaded tools, limited automation, and workflows that haven't fundamentally changed in decades. Zoo is building the infrastructure to change that, creating a modern set of tools and APIs that will allow companies and engineers to build better hardware design tools and accelerate the development of physical products.

Today we're joined by Jessie Frazelle, CEO of Zoo (formerly KittyCAD), to talk about migrating core parts of Zoo's infrastructure to Rust, boring infrastructure, how Rust can help bridge the gap between software and hardware development, and how Zoo is building the foundation for the next generation of hardware development tools.

While software engineering has evolved with powerful tools and workflows, hardware design is still stuck 'the dark ages.' Zoo's mission is to make building hardware products as seamless as building software.

Zoo is working on everything from graphics engines to automated workflows for mechanical engineers, and they're even developing their own file format in collaboration with industry leaders. Their goal is to become the foundation that powers the next generation of hardware design tools, making it possible for individuals and small teams to build innovative solutions that were previously only possible within major companies.

Jessie Frazelle is the CEO of Zoo and a former software engineer at Microsoft, Docker, and Google. She's a contributor to many well-known open-source projects and has a background in security, containers, and cloud computing. Jessie is also a prolific speaker and writer, and she's passionate about making technology fun and accessible to everyone.

Version control is a critical part of any modern software project and git is the most popular tool for the job. But it can be complex and confusing, especially for beginners.

The team behind GitButler believes there is a better way.

They are building a modern Git client that streamlines the process of managing branches, backing up your work, and more. We hear from co-founders Scott Chacon and Kiril Videlov about how they're making Git easier for everyone -- all without sacrificing the power and flexibility that makes Git so popular in the first place.

Git Branching, Refined — that's the promise of GitButler. GitButler is a Git client that helps you manage your Git branches more effectively. GitButler records and backups up your work, helps with your code and much more. Their focus is everything after writing code in your editor and before sharing it on GitHub. The client is written in Rust, by the way.

Scott Chacon is a co-founder of GitButler. Previously, he was a co-founder at GitHub. Scott is the author of the famous Pro Git book (which taught me Git, thank you very much) and an investor in a number of companies through his incubator, SCNE. He somehow also found the time to get a B2 in German.

Kiril Videlov is a co-founder and CTO of GitButler. He has a background in software engineering, especially in the fields of fintech and code analysis. He is a YC alum and has a Master's degree in Computer Science.

Links From The Episode (In Chronological Order) 

"Rust in Production" is a podcast by corrode, a company that helps teams adopt Rust. We offer training, consulting, and development services to help you succeed with Rust. If you want to learn more about how we can help you, please get in touch.

What's even cooler than writing your own text editor or your own operating system? Building your own hardware from scratch with all the software written in Rust -- including firmware, the scheduler, and the hypervisor. Oxide Computer Company is one of the most admired companies in the Rust community. They are building "servers as they should be" with a focus on security and performance to serve the needs of modern on-premise data centers.

In this episode, I talk to Steve Klabnik, a software engineer at Oxide and renowned Rustacean, about the advantages of building hardware and software in tandem, the benefits of using Rust for systems programming, and the state of the Rust ecosystem.

Founded by industry giants Bryan Cantrill, Jessie Frazelle, and Steve Tuck, Oxide Computer Company is a beloved name in the Rust community. They took on the daunting task of rethinking how servers are built -- starting all the way from the hardware and boot process (and no, there is no BIOS). Their 'On The Metal' podcast is a treasure trove of systems programming stories and proudly served as a role model for 'Rust in Production.'

In the Rust community, Steve does not need any introduction. He is a prolific writer, speaker, and software engineer who has contributed to the Rust ecosystem in many ways -- including writing the first version of the official Rust book. If you sent a tweet about Rust in the early days, chances are Steve was the one who replied. Previously, he worked at Mozilla and was a member of the Rust and Ruby core teams.

Links From The Episode (In Chronological Order)
 

Picture this: Your organization's data infrastructure resembles a busy kitchen with too many cooks. You're juggling Kafka for messaging, Flink for processing, Spark for analytics, Airflow for orchestration, and various Lambda functions scattered about. Each tool excellent at its job, but together they've created a complex feast of integration challenges. Your data teams are spending more time managing tools than extracting value from data.
InfinyOn reimagines this chaos with a radically simple approach: a unified system for data streaming that runs everywhere. Unlike traditional solutions that struggle at the edge, InfinyOn gracefully handles data streams from IoT devices to cloud servers. And instead of cobbling together different tools, developers can build complete data pipelines using their preferred languages - be it Rust, Python, or SQL - with built-in state management.

At the heart of InfinyOn is Fluvio, a Rust-based data streaming platform that's fast, reliable, and easy to use.

Data pipelines are often slow, unreliable, and complex. InfinyOn, the creators of Fluvio, aims to fix this. Built in Rust, Fluvio offers fast, reliable data streaming. It lets you build event-driven pipelines quickly, running as a single 37 MB binary. With features like SmartModules, it handles various data types efficiently. Designed for developers, it offers a clean API and intuitive CLI. Streamline your data infrastructure at infinyon.com/rustinprod.

For fifteen years, Deb has been a behavioral detective, piecing together human decision-making through conversations, data, and research. His passion lies in product innovation—finding that sweet spot where desirability, viability, and feasibility converge. From 7-person startups to tech giants of 165,000, he helped build products that people love. Deb is currently the VP of Product Management at InfinyOn, where he leads the product strategy and roadmap for Fluvio, a Rust-based data streaming platform.

"Rust in Production" is a podcast by corrode, a company that helps teams adopt Rust. We offer training, consulting, and development services to help you succeed with Rust. If you want to learn more about how we can help you, please get in touch.

About Zed Industries

Zed isn't afraid of daunting tasks. Not only have they built a text editor from scratch, but they've also developed their own GUI toolkit, implemented advanced parsing techniques like tree-sitter, and integrated multi-user collaboration features directly into the editor. Zed is a text editor built for the future, with meticulous attention to detail and a focus on exceptional performance.

About Conrad Irwin

Before joining Zed, Conrad worked on Superhuman, an email client renowned for its speed and efficiency. He is a seasoned developer with a deep understanding of performance optimization and building fast, reliable software. Conrad is passionate about open-source software and is a strong advocate for Rust. He's also an excellent pair-programming partner and invites people to join him while working on Zed.

About corrode

"Rust in Production" is a podcast by corrode, a company that helps teams adopt Rust. We offer training, consulting, and development services to help you succeed with Rust. If you want to learn more about how we can help you, please get in touch.

Results from the Survey 

A few weeks ago, we asked you to fill out a survey about the Rust in Production podcast. Thank you to everyone who participated! We received a lot of valuable feedback. 

In total, we got 82 responses. Here are some of the key takeaways: 

How did you discover the "Rust in Production" podcast? 

How Many Episodes Have You Listened To?

Which Aspects Of The Show Do You Enjoy The Most?

Top 5 topics listeners want to see covered in future episodes:

Top 5 suggested changes for the podcast:
 

Current level of experience with Rust among listeners:
 

How listeners typically listen to "Rust in Production":
 

How 'Rust in Production' influenced perception of Rust's viability in production:
 

Aspects of Rust in Production listeners are most interested in:
 

Formats listeners are most interested in:
 

Office Hours:
Join our Corrode Office Hours every Thursday at 4 PM UTC. Bring your questions, and we'll try to help you out! Dates: August 15, 22, 29; September 5, 12, 19, 26; October 3. To learn more, check out the office hours page on our website: https://corrode.dev/office-hours
 
Links from the Episode:

The History of Rust - Steve Klabnik: https://youtu.be/79PSagCD_AY?si=oNH9u1HPQ9welYjZ
Nickel Framework by Christoph Burgdorf: https://nickel-org.github.io
tokio on crates.io: https://crates.io/crates/tokio
The 'New Rustacean' podcast: https://newrustacean.com/
Simon Brüggen (M3t0r) on GitHub: https://github.com/M3t0r
Simon Brüggen (M3t0r) on Mastodon: https://hachyderm.io/@m3t0r
Matthias Endler on Mastodon: https://mastodon.social/@mre
About corrode Rust Consulting: https://corrode.dev/about
'Rust in Production' Podcast on Apple: https://podcasts.apple.com/us/podcast/rust-in-production/id1720771330 'Rust in Production' Podcast on Spotify: https://open.spotify.com/show/0Hf6gWrzpSzXp1X0cebbsT

Credits:
Audio editing and mastering by Simon Brüggen (M3t0r).
 
About corrode:
"Rust in Production" is a podcast by corrode, a company that helps teams adopt Rust. We offer training, consulting, and development services to help you succeed with Rust. If you want to learn more about how we can help you, please get in touch.

Many devs dream of one day writing their own operating system. Ideally in their favorite language: Rust. For many of us, this dream remains just that: a dream.

Jeremy Soller from System76, however, didn't just contribute kernel code for Pop!_OS, but also started his own operating system, RedoxOS, which is completely written in Rust. One might get the impression that he likes to tinker with low-level code!

In this episode of Rust in Production, Jeremy talks about his journey. From getting hired as a kernel developer at Denver-based company System76 after looking at the job ad for 1 month and finally applying, to being the maintainer of not one but two operating systems, additional system tools, and the Rust-based Cosmic desktop. We'll talk about why it's hard to write correct C code even for exceptional developers like Jeremy and why Rust is so great for refactoring and sharing code across different levels of abstraction.

From hardware all the way up to the UI, System76 pushes hard for vertical integration. The company has a strong following amongst Linux enthusiasts and is a big advocate for Rust. They use it across the stack for most (all?) of their major projects. Instead of GNOME or KDE, the Denver-based company even built their own user interface in Rust, called COSMIC.

Jeremy is a hardware and kernel hacker who has an intricate understanding of low-level computing. With Redox OS, an operating system fully written in Rust, he was one of the first developers who pushed the boundaries of what was possible with the still young language. The first release of Redox was in April 2015 when Rust hadn't even reached 1.0. By all means, Jeremy is a pioneer in the Rust community, an expert in low-level programming, and an advocate for robust, reliable systems programming.

Data pipelines are often slow, unreliable, and complex. InfinyOn, the creators of Fluvio, aims to fix this. Built in Rust, Fluvio offers fast, reliable data streaming. It lets you build event-driven pipelines quickly, running as a single 37 MB binary. With features like SmartModules, it handles various data types efficiently. Designed for developers, it offers a clean API and intuitive CLI. Streamline your data infrastructure at infinyon.com/rustinprod.

"Rust in Production" is a podcast by corrode, a company that helps teams adopt Rust. We offer training, consulting, and development services to help you succeed with Rust. If you want to learn more about how we can help you, please get in touch.

Rust can run everywhere, and by everywhere, we don't just mean on all operating systems, but also in all kinds of harsh environments: from the depths of the ocean to the vastness of space. Today we talk to a company that is using Rust to conquer the air. Fusion Engineering is building drone control systems for the next generation of drones.

Jakub Valtar walks us through how Fusion Engineering came to use Rust as the foundation of their company. He explains why Rust is the safest choice for building drone control systems and what it takes to get into drone development.

Fusion Engineering identified a critical gap in the industry: while drone hardware has advanced rapidly, software development has lagged behind.

Their approach is ambitious - developing drone control systems from the ground up, with a strong focus on safety. It's about making drones fly reliably in complex environments.

Their flight controller is designed to meet the most stringent EU regulations, potentially allowing drones to operate safely in urban areas and withstand harsh conditions offshore.

Jakub Valtar is a game engine developer turned drone software engineer. He feels comfortable in performance-critical environments and loves the intersection between art and technology. He joined Fusion Engineering to work on control systems for the next generation of drones.

"Rust in Production" is a podcast by corrode, a company that helps teams adopt Rust. We offer training, consulting, and development services to help you succeed with Rust. If you want to learn more about how we can help you, please get in touch.

It has become a trope by now: "Cars are computers on wheels." In modern cars, not only the infotainment system but also the engine, brakes, and steering wheel are controlled by software. Better make sure that software is safe.

Alexandru Radovici is a Software Engineer at OxidOS, a company that builds a secure, open-source operating system for cars built on Rust and Tock. We talk about the challenges of certifying Rust code for the automotive industry and the new possibilities with Rust-based car software.

OxidOS is a Rust-based secure ecosystem for safety critical automotive ECUs. Their solution consists of a Rust-based Secure Operating System and DevTools for medium-size microcontrollers inside automotive ECUs, designed for safety-critical applications. The OxidOS ecosystem provides significant security and safety enhancements while reducing development and certification time by half for automotive ECU software development projects. This is achieved through the usage of Rust that brings benefits such as memory and thread safety enforced at compile time. The OxidOS architecture runs memory sandboxed applications, which have cryptographic credentials and are digitally signed.

Alexandru Radovici is an Associate Professor at the Politehnica University in Bucharest, Romania, where he has been using Rust to teach for a few years. Alexandru is also one of the maintainers of the Tock embedded operating system, written fully in Rust.

"Rust in Production" is a podcast by corrode, a company that helps teams adopt Rust. We offer training, consulting, and development services to help you succeed with Rust. If you want to learn more about how we can help you, please get in touch.

Matic is on a mission to solve everyday problems with robotics. Design Milk wrote in an article about Matic: "Matic Robot Vacuum Collects Dust but Not Your Personal Data" and I really love that quote. It's a great summary of what Matic is about: privacy-respecting, truly smart robots. The San Francisco-based startup recently raised a $24M Series A round.

Eric is a systems engineer with a passion for reliable, well-designed software. He has a background in kernel development and high-performance computing with C++ and now works on robotics with Rust.

With his calm and insightful demeanor, Eric is the ideal person to talk about Rust's strengths for people with a C++ background.

"Rust in Production" is a podcast by corrode, a company that helps teams adopt Rust. We offer training, consulting, and development services to help you succeed with Rust. If you want to learn more about how we can help you, please get in touch.

The MZLA Technologies Corporation is a fully-owned subsidiary of Mozilla that develops and maintains the Thunderbird email client. The project can be supported at give.thunderbird.net.

Brendan joined the Thunderbird team in 2023 and has been working on the Rust-based Exchange protocol support. Previously, he worked on the Matrix protocol and the Element chat client. He is a strong advocate for open-source software and maintains projects written in Rust, Python, and Go.

AMP gives waste and recycling leaders the power to harness artificial intelligence and solve the industry’s biggest challenges. The company uses cutting-edge technology to help waste and recycling facilities improve their operations and increase recycling rates.

AMP transforms the economics of the waste industry to make recycling more efficient, cost-effective, scalable, and sustainable.

Carters Schultz is a Robotics Architect at AMP Robotics. He has a background in robotics and computer vision. Previous employers include Neya Systems and SpaceX. An engineer at heart, Carter is passionate about building systems that work reliably and efficiently and pushes the boundaries of what is possible with technology. He is a charismatic speaker and curious mind with a passion for teaching and learning.

"Rust in Production" is a podcast by corrode, a company that helps teams adopt Rust. We offer training, consulting, and development services to help you succeed with Rust. If you want to learn more about how we can help you, please get in touch. 

In the season finale of 'Rust in Production', we take a cold, hard look at our goals and achievements during the first season.

Did we manage to answer the tough questions about Rust's usage in the industry? Were we able to provide a balanced view of the challenges and benefits of using Rust? Or did we end up merely preaching to the choir?

As it turns out, the answers align nicely with the main themes from the Rust 2023 survey: the hiring market, the learning curve, the reasons for choosing Rust, the costs of adoption, and the complexity of the language. Either way, there were definitely some surprises and unexpected turns along the way!

Links from the Episode (in order of appearance):

https://blog.rust-lang.org/2015/05/15/Rust-1.0.html
https://blog.rust-lang.org/2016/11/10/Rust-1.13.html#the--operator
https://blog.rust-lang.org/2019/11/07/Async-await-stable.html
https://www.youtube.com/@HelloRust
https://corrode.dev/podcast/s01e01-influxdata/?t=55%3A40
https://corrode.dev/podcast/s01e05-tweede-golf?t=16%3A29
https://corrode.dev/podcast/s01e02-pubnub?t=16%3A24
https://corrode.dev/podcast/s01e03-apollo?t=7%3A24
https://corrode.dev/podcast/s01e04-arroyo?t=17%3A40
https://corrode.dev/podcast/s01e06-sentry?t=54%3A03
https://corrode.dev/podcast/s01e02-pubnub?t=17%3A25
https://corrode.dev/podcast/s01e05-tweede-golf?t=18%3A57
https://corrode.dev/podcast/s01e03-apollo?t=35%3A32
https://corrode.dev/podcast/s01e01-influxdata/?t=25%3A25
https://corrode.dev/podcast/s01e01-influxdata/?t=49%3A47
https://www.integer32.com/
https://corrode.dev/podcast/s01e06-sentry?t=57%3A16
https://corrode.dev/podcast/s01e01-influxdata/?t=46%3A49
https://corrode.dev/podcast/s01e04-arroyo?t=29%3A42
https://corrode.dev/podcast/s01e04-arroyo?t=29%3A20
https://corrode.dev/podcast/s01e05-tweede-golf?t=13%3A18
https://corrode.dev/podcast/s01e05-tweede-golf?t=15%3A13
https://github.com/rust-lang/rust/tree/master/library
https://crates.io/crates?sort=downloads
https://corrode.dev/podcast/s01e02-pubnub?t=37%3A24
https://corrode.dev/podcast/s01e03-apollo?t=24%3A09
https://crates.io/crates/tokio
https://crates.io/crates/axum
https://crates.io/crates/sqlx
https://newrustacean.com/
https://oxide.computer/podcasts/on-the-metal
https://github.com/M3t0r
https://hachyderm.io/@m3t0r
https://mastodon.social/@mre
https://corrode.dev/about
https://podcasts.apple.com/us/podcast/rust-in-production/id1720771330
https://open.spotify.com/show/0Hf6gWrzpSzXp1X0cebbsT

Additional Links:

https://blog.rust-lang.org/2023/12/20/Rust-2023-Survey-Results.html
https://www.premiumbeat.com/royalty-free-tracks/cassiopeia

All Episodes of Season 1:

https://corrode.dev/podcast/s01e01-influxdata
https://corrode.dev/podcast/s01e02-pubnub
https://corrode.dev/podcast/s01e03-apollo
https://corrode.dev/podcast/s01e04-arroyo
https://corrode.dev/podcast/s01e05-tweede-golf
https://corrode.dev/podcast/s01e06-sentry

Credits:
We would like to thank the guests of the first season for their time and insights. We would also like to thank the listeners for their support and feedback. We are looking forward to the second season and hope you will join us again!

Audio editing and mastering by Simon Brüggen (M3t0r).

About corrode:
"Rust in Production" is a podcast by corrode, a company that helps teams adopt Rust. We offer training, consulting, and development services to help you succeed with Rust. If you want to learn more about how we can help you, please get in touch.

https://corrode.dev/about

In this episode, we talk to Arpad Borsos, Systems Software Engineer at Sentry, about how they use Rust to build a modern error monitoring platform for developers.

We discuss the challenges of building a high-performance, low-latency platform for processing and analyzing large amounts of data (like stack traces and source maps) in real-time. 

Arpad maintains the `symbolic` crate for stack trace symbolication, which is used on the Sentry platform.

About Sentry:
Sentry provides application performance monitoring and error tracking software for JavaScript, Python, Ruby, Go, and more. Their platform also supports session replay, profiling, cron monitoring, code coverage, and more.

About Arpad Borsos:
Arpad Borsos works on high-performance, low-latency systems and maintains open source projects like the popular `rust-cache` GitHub Action. He is an expert in asynchronous programming and spoke about async functions at EuroRust 2023.

Links From The Show:
- https://github.com/getsentry/relay
- https://github.com/getsentry/symbolic
- https://crates.io/crates/tracing
- https://actix.rs/
- https://firefox-source-docs.mozilla.org/js/index.html
- https://en.wikipedia.org/wiki/Name_mangling
- https://neon-bindings.com/
- https://github.com/PyO3/maturin
- https://docs.rs/sentry/latest/sentry/
- https://github.com/getsentry/sentry-rust
- https://en.wikipedia.org/wiki/Minification_(programming)#Source_mapping
- https://github.com/Swatinem/rust-cache
- https://tokio.rs/
- http://formats.kaitai.io/windows_minidump/

Official Links:
- https://sentry.io/
- https://github.com/getsentry/sentry
- https://sentry.engineering/
- https://www.linkedin.com/in/swatinem/
- https://github.com/Swatinem
- https://swatinem.de/

The Network Time Protocol (NTP) is a cornerstone of the internet. It provides accurate time synchronization on millions of devices, but its C-based implementation, which dates back to the 1980s, is showing its age. In this episode, we talk to Folkert de Vries, Systems Software Engineer at Tweede Golf, about their work on reimplementing NTP in Rust as part of Project Pendulum.

ntpd-rs is an open-source implementation of the Network Time Protocol, completely written in Rust with the goal of creating a modern, memory-safe implementation of the NTP protocol.

Funding for the project came from the Internet Security Research Group and the Sovereign Tech Fund.

Tweede Golf is a Dutch software consultancy that specializes in safe and privacy-friendly software. They work on projects that are critical for creating a safe internet infrastructure, protecting citizens' privacy, and securing connected devices with Embedded Rust.

Tweede Golf is also an organizing partner of RustNL, a conference about the Rust programming language, which takes place in the Netherlands.

Folkert is a Systems Software Engineer at Tweede Golf, where he works on low-level protocols that ensure the safety and security of the internet and devices connected to it. He is an open source maintainer and polyglot, working with and extending languages as diverse as Rust, Elm, and Roc.

About Arroyo
Arroyo was founded in 2022 by Micah Wylde and is based in San Francisco, CA. It is backed by Y Combinator (https://www.ycombinator.com/) (YC W23). The companies' mission is to accelerate the transition from batch-processing to a streaming-first world.

About Micah Wylde
Micah was previously tech lead for streaming compute at Splunk and Lyft, where he built real-time data infra powering Lyft's dynamic pricing, ETA, and safety features. He spends his time rock climbing, playing music, and bringing real-time data to companies that can't hire a streaming infra team.

Tools and Services Mentioned
- Apache Flink: https://flink.apache.org/
- Tokio Discord: https://discord.gg/tokio
- Clippy: https://github.com/rust-lang/rust-clippy
- Zero to Production in Rust by Luca Palmieri: https://www.zero2prod.com/
- Apache DataFusion: https://github.com/apache/arrow-datafusion
- Axum web framework: https://github.com/tokio-rs/axum
- `sqlx` crate: https://github.com/launchbadge/sqlx
- `log` crate: https://github.com/rust-lang/log
- `tokio tracing` crate: https://github.com/tokio-rs/tracing
- wasmtime - A standalone runtime for WebAssembly: https://github.com/bytecodealliance/wasmtime

References To Other Episodes
- Rust in Production Season 1 Episode 1: InfluxData: https://corrode.dev/podcast/s01e01-influxdata

Official Links
- Arroyo Homepage: https://www.arroyo.dev/
- Arroyo Streaming Engine: https://github.com/ArroyoSystems/arroyo
- Blog Post: Rust Is The Best Language For Data Infra: https://www.arroyo.dev/blog/rust-for-data-infra
- Micah Wylde on LinkedIn: https://www.linkedin.com/in/wylde/
- Micah Wylde on GitHub: https://github.com/mwylde
- Micah Wylde's Personal Homepage: https://www.micahw.com/