Matthias: It's time for another episode of Rust in Production. I'm Matthias Endler from
Matthias: corrode, and today we're wrapping up Season 3 and our first year of producing this podcast.
Matthias: In December 23, we launched this podcast to uncover stories about Rust in production.
Matthias: Since then, we've watched Rust transform from a fringe language choice into
Matthias: a powerhouse that drives critical production workloads.
Matthias: This season, we had very different guests from all sorts of industries.
Matthias: From developer tools with Zed and Gitbutler, over infrastructure with Fluvio
Matthias: and Oxide, to browser technology with Brave and C8E software with Su,
Matthias: all the way to automotive with Volvo.
Matthias: The conversation about Rust has shifted dramatically.
Matthias: Companies don't pitch Rust as an innovation anymore, they pick it as their go-to
Matthias: language when replacing legacy systems.
Matthias: I've even seen competing companies build multiple parallel implementations of
Matthias: the same thing in Rust. The well-known ThoughtWorks tech radar now ranks Rust
Matthias: as well-established in systems programming.
Matthias: Rust has carved out strongholds in safety-critical sectors, especially automotive,
Matthias: and dominates the developer tooling space. Let's hear Steve Klabnik from Oxide.
Steve: A lot of people don't realize how much production Rust is out there and how
Steve: many companies truly depend on it.
Steve: And if the idea if rust like were to suddenly
Steve: implode how people wouldn't
Steve: step up to fix it like just meta
Steve: alone has i think like on the
Steve: order of 10 million lines of rust it's like i don't think it's
Steve: it's a hundred million lines but i think it's more than single digit millions
Steve: it's like between one and 10 million lines of rust you know amazon like rust
Steve: is now involved in like s3 aws like aws ec2 uh tons of different aws servers
Steve: are all like have rust at really key points i mean rust is in the windows kernel already of.
Matthias: All the stories we heard the one from volvo caught me completely off guard in
Matthias: the best way possible i never expected traditional car manufacturers to jump
Matthias: on rust so quickly yet here we are,
Matthias: And alongside Renault and others, they bet big on Rust.
Matthias: That shift tells us something important. Rust has evolved beyond its system
Matthias: programming roots into a solution for building reliable software at scale,
Matthias: regardless of the industry.
Matthias: Web development's Rust revolution surprised me too.
Matthias: Of course, the benefits seem obvious now. Who doesn't want better performance
Matthias: and reliability, I guess?
Matthias: But the sheer speed and scale of adoption?
Matthias: Well, that blew me away. I personally like that more smaller companies are coming
Matthias: forward with their Rust usage now.
Matthias: Okay, now let's dig into the last
Matthias: eight episodes and unpack how different companies tackle Rust adoption.
Matthias: Their stories maybe can teach us valuable lessons about bringing Rust into production. Chapter 2.
Matthias: Enterprise Adoption Patterns The way enterprises adopt Rust has matured significantly.
Matthias: For example, the Chrome team invests heavily into Rust by integrating it into
Matthias: the browser's build system, which is far from a trivial task and requires careful alignment.
Matthias: Anton Lazarev from Brave shares some insights.
Anton: Chrome took a very measured approach, in particular, with adopting Rust.
Anton: I think they've been interested in it for a while, but they wanted to really
Anton: stress test it and make sure that they have good integration with their build
Anton: process and that everything works and doesn't cause unexpected issues out in the wild.
Anton: Because they have a huge user base.
Anton: Things can go very wrong in ways that you have no idea about.
Anton: So they were prototyping a way to include Rust code in their code base for a while.
Anton: And we were watching that with a lot of interest because obviously we had our
Anton: own build system integrating with Rust for a while.
Anton: And we had ours pretty early on and we were pretty confident about it.
Anton: And we just said, we'll try it. We'll see what happens.
Anton: And as a result, we had it working pretty well.
Anton: And I'm not sure if the Chrome team looked at us as a success story,
Anton: but we were certainly available at the time.
Matthias: This integration process is quite complex. It might make sense to get external
Matthias: support for guidance and to save time.
Matthias: Here is Julius Gustafsson from Volvo.
Julius: Yeah, so we brought on these experts. They were the foremost experts in Sweden at the time.
Julius: And they also, they helped us,
Julius: get started and and helped us with a lot of the driver development and and things
Julius: like that so so i would say that is also a big piece of the puzzle to get good
Julius: people to help you get started either either from within the company or externally
Julius: depending on what options do you have in.
Matthias: General we see adoption patterns shift across the industry previously greenfield projects were the norm.
Matthias: However, SLAs and longer lead times are now part of the conversation.
Matthias: Support for legacy systems is a must-have.
Matthias: Partial migrations are now more common. That's because Rust just plays very
Matthias: nicely with other ecosystems.
Matthias: Teams actively compare Rust with alternatives, like Java with Quarkus.
Matthias: And maybe a full rewrite isn't necessary after all.
Matthias: In general, it's a more conservative, measured pace of adoption.
Matthias: And the numbers back it up. Teams I consult for consistently build 100,000 line
Matthias: code bases within six months.
Matthias: Legacy code ports are more straightforward than commonly expected,
Matthias: especially with one or two Rust champions leading the team.
Matthias: Google's director of engineering, Lars Bergström, even reported that Rust teams
Matthias: are twice as productive as teams using C++.
Matthias: They've seen Android memory vulnerabilities drop by 52% after switching to Rust.
Matthias: But what fascinates me the most is how teams grow into Rust.
Matthias: Their journey typically spans two distinct phases.
Matthias: Year one focuses on fundamentals. Onboarding developers, proving feasibility,
Matthias: making time for adoption, and so on.
Matthias: Year two tackles bigger challenges. Establishing design patterns,
Matthias: maintaining code quality, managing compile times at scale, building systems
Matthias: for knowledge transfer, improving developer experience and so on.
Matthias: I've watched teams repeatedly succeed with this methodical approach.
Matthias: The key is to keep things simple. Focus on the developer experience and use
Matthias: each language where it makes the most sense.
Matthias: Hype-driven development sucks and backwards compatibility is a big win.
Matthias: Here is Scott Shakin, co-founder of GitHub and now founder of GitButler on the same topic.
Scott: I don't like clever code, right? I like dumb code that is easy to understand and easy to modify.
Scott: And so I always kind of go away from super clever stuff because even though
Scott: it makes you feel smart, it may not.
Scott: And that's why it makes you feel smart is because somebody else has a harder
Scott: time understanding it or figuring it out. Like I don't like magic.
Matthias: Conrad Irwin from Zed agrees.
Conrad: I've been doing Rust for about a year now and I just about feel like a beginner.
Conrad: So if we can make it simpler for people joining in, I think that will help with everything.
Conrad: One thing I learned, we did a rewrite of GPUI, the graphics framework,
Conrad: that was fairly heavy on use of generics and ended up exporting a bunch of things
Conrad: that were instantiated multiple times with multiple different types.
Conrad: And the way that Rust compiles generics is to kind of copy-paste the code each time for each type.
Conrad: And so we had some kind of big compile-time regressions at that point,
Conrad: just because of the way the code was structured.
Matthias: Chapter three, not all that glitters. Not every Rust adoption story ends in success.
Matthias: It's worth looking at the other side of the coin. For example,
Matthias: the game dev space hasn't picked up Rust as quickly as I expected.
Matthias: No AAA title in sight.
Matthias: There's a thoughtful article called Leaving Rust for Game Dev that explains why.
Matthias: Perhaps Rust isn't the best fit for game development after all.
Matthias: Of course, there are systems like Bevi, but its entity component system and
Matthias: trade-based approach takes a while to get used to.
Matthias: Paired with the tendency to work on mutable state in gamedev,
Matthias: many developers initially hit
Matthias: a wall when they tried to use Rust for their first big gamedev project.
Matthias: Well, at least we have TinyGlade, which is a game fully written in Rust that
Matthias: recently launched on Steam.
Matthias: Even a Linux kernel adoption does not go without drama. Who would have guessed?
Matthias: The message is clear. Use the right tool for the job.
Matthias: Sometimes that's Rust. Sometimes it's Zig. And sometimes it's something else
Matthias: entirely. Let's hear Jessie Frazelle from Zoo.
Jessie: Our CAD kernel is also sadly not written in Rust, it's written in C++.
Jessie: And that was because Vulkan and a lot of the CUDA libraries,
Jessie: like all of the good graphics libraries and like NURBS libraries are in C++.
Jessie: And you could generate bindings for them, but it will never be the same.
Jessie: I've used the CUDA Rust bindings and like it leaves a lot to be desired.
Jessie: I actually think hopefully there will be better ones soon.
Matthias: And here's Deb Roy Chowdhury from Infineon.
Deb: The co-founders, they actually were initially debating on whether to use Golang
Deb: or Rust to build Fluvio five years ago.
Deb: And it was a fairly contentious decision and the CTO won that debate and Rust was selected.
Deb: They had done a bunch of Golang work with server side and Golang is pretty fast, right?
Deb: But the things that are most difficult to learn in Rust for beginners,
Deb: like borrower checker, like async traits, are the ones that guarantee safety
Deb: and security and guarantee that you get your data the way you want it.
Deb: And this is why we made, or the CTO and the CEO, when they were making the decision,
Deb: made the choice to write the Fluvia project in Rust.
Matthias: In Season 2, we had Daniel Stenberg talk about Rust's adoption in CURL.
Matthias: As of recently, Hyper, the HTTP backend written in Rust, was removed again from the CURL codebase.
Matthias: He mentioned outstanding issues with hyper and other crates,
Matthias: which no one had the time or patience to tackle.
Matthias: That said, Rust-TLS, which stands for Transport Layer Security Protocol, is still part of Curl.
Matthias: Heck, even ThePrimeagen, a prominent YouTuber and content creator, moved away from Rust.
Matthias: But more seriously, there's a major trend pushing Rust adoption, which is practicality.
Matthias: Companies increasingly choose Rust for non-technical reasons.
Matthias: Every year it's getting harder to find good Perl or Scala developers.
Matthias: Even great C and C++ engineers are hard to find. And as a consequence,
Matthias: new projects rarely start in C++ anymore.
Matthias: I recently heard that even some conservative companies, like my insurance provider,
Matthias: are slowly moving to Rust simply because that's where the talent is.
Matthias: These practical considerations often outweigh technical arguments.
Matthias: In a contracting economy, especially when we are facing a recession,
Matthias: cost becomes a primary driver.
Matthias: Production bugs are the biggest cost factor next to salaries after all.
Matthias: And Rust's promise of shifting complexity to the left, which means to development
Matthias: and away from production, catching issues at compile time rather than later
Matthias: on where it's more expensive,
Matthias: resonates strongly with business leaders.
Matthias: Chapter 4. Community Evolution The Rust community hit some impressive milestones this year.
Matthias: We crossed 100 billion crate downloads.
Matthias: A number that seemed impossible just a few years ago. The Rust subreddit now
Matthias: also has more subscribers than C++.
Matthias: But raw numbers only tell part of the story.
Matthias: The nature of discussions has shifted dramatically as well.
Matthias: People no longer ask, is Rust used in production? Instead, they ask,
Matthias: who uses Rust in my industry?
Matthias: That's a major shift forward in the public debate about Rust adoption.
Matthias: The ecosystem shows its maturity. Core crates like serde and clap are rock solid.
Matthias: The ecosystem feels complete for 90% of the core use cases.
Matthias: Here's Kiril Videlov from GitButler.
Kiril: The median quality of a library or crate that you can find is greater than the
Kiril: median quality of other ecosystems.
Kiril: And I have been exploring languages for many years now, and I genuinely feel this way.
Matthias: Yet, this growth brings new challenges. Creates.io shows its limitations.
Matthias: For example, it still doesn't support two-factor authentication,
Matthias: and name squatting is a constant annoyance.
Matthias: Personally, I would also like to see the addition of namespaces,
Matthias: but I know that's a controversial topic.
Matthias: Some teams have faced challenges with cargo at scale.
Steve: You know, it's nice and it's got its problems too. Like, you know,
Steve: I mentioned cargo being really useful before.
Steve: It is true that cargo is wonderful and it's definitely very useful,
Steve: but also we basically had to write a build system on top of cargo to make this
Steve: work because cargo has several deficiencies with dealing with this kind of problem.
Steve: Is actually one of the first things that i worked on at oxide was sort
Steve: of rewriting the build system yet again on top
Steve: of cargo you know definitely like it is
Steve: it is a very different thing than developing a
Steve: web app or developing something that's a much higher level and you
Steve: know it's definitely some people enjoy it and some people don't and you
Steve: know i used to work on that stuff and i found that it was a pleasure but
Steve: you know obviously everybody has their different levels of expertise tell me
Steve: a little bit about that what were some of the limitations that you
Steve: ran into with cargo and also why did you have to build your own build system
Steve: how does that look like yeah so a very simple
Steve: and straightforward one is that cargo kind of very deliberately does
Steve: not include any post-processing of stuff and we need to build an operating system
Steve: image so like on some level there is a step after cargo runs you know cargo
Steve: produces a program or a couple programs and then we need to like assemble that
Steve: into a thing that you would actually you know load onto to the microprocessor.
Matthias: However, this approach remains the exception. For the most part, Cargo works just fine.
Matthias: And where it lacks in functionality, other ecosystems like ProbeOS improve developer
Matthias: experience for embedded environments, for example.
Matthias: The community faces different problems than it did in the past.
Matthias: How do we handle knowledge transfer in larger teams? How do we maintain consistency
Matthias: across massive code bases?
Matthias: How do we handle the scale that comes with success? I've noticed a shift in the people too.
Matthias: The early enthusiasts who shaped Rust's direction are still around,
Matthias: but they are now joined by practical engineers who just want to get stuff done.
Matthias: Some might even say Rust is the new Java. And while that might sound a bit negative,
Matthias: it actually signals that Rust becomes a mainstream language.
Matthias: I personally use Rust for everything from prototyping to production,
Matthias: and it feels great to have a single stack across all programming tasks.
Matthias: Julius Gustafsson from Volvo agrees.
Julius: We quite quickly figured that
Julius: having a 100% Rust-based solution would actually be a much better choice.
Julius: Why? Yeah, because you don't have to worry about all these FFI boundaries between
Julius: C and also when you're building it on bare metal embedded,
Julius: it kind of depends on what compiler you're using, what linkers you're using,
Julius: because the C libraries, they expect certain initialization to be done in a certain way.
Julius: And so there may be incompatibilities there that, yeah, so even though Rust
Julius: and C can interoperate seamlessly, there are.
Julius: There can be some issues when you're doing it on a bare metal target like this.
Julius: The fact that you can actually, you know, take different components from the
Julius: community and you can use them with confidence that you don't really have another.
Julius: I mean, both hassle-free, almost always. It just builds and works and you can just use it.
Julius: And also, you know, all these things that you always have to take care of.
Julius: First, you need to, okay, can you get it to build in my build system?
Julius: You know, and first time, probably not.
Julius: You probably need to spend a lot of time to get that to work.
Julius: But then when it actually builds and you start to use it, does it use memory
Julius: in the same way as you do? Does it make the same assumptions?
Julius: Like who is allocating this buffer? Who is freeing it?
Julius: Who has the responsibility to do what?
Julius: And so on and so forth. Those are not standardized in C and C++,
Julius: meaning that, yeah, so even if you can build it, it's no guarantee that you
Julius: can actually use it in any productive way.
Julius: But in Rust, on the other hand, everything is, maybe it's not true to say everything,
Julius: But I mean, you're pretty much guaranteed that it will work.
Julius: And also, like you said, I don't
Julius: think there's any language that is as scalable, like from the lowest,
Julius: smallest microcontrollers to like backend systems or whatever biggest server
Julius: farms that you can imagine and everything in between.
Matthias: Big tech's influence on Rust grows stronger.
Matthias: Google, Microsoft and AWS shape Rust's development through the Rust Foundation as Platinum members.
Matthias: For better or worse, they control a large part of the narrative now.
Matthias: But Rust's heart still beats through individual contributors.
Matthias: We need to support them more.
Matthias: Companies need to step up their sponsoring game. The number of conferences has exploded.
Matthias: I can barely keep track of all the Rust events anymore.
Matthias: That's why I created a dedicated calendar with all events.
Matthias: Check out the show notes for the link if you're interested. But there's still room for more.
Matthias: I wish for more US-based conferences in the future and more efforts like Rust Asia.
Matthias: We also need a conference or two in Africa. Does anyone want to rise up to the occasion?
Matthias: It's normal now to run into Rustations at any tech company I talk to.
Matthias: Sometimes they're quietly using Rust for internal tooling. sometimes they're
Matthias: building entire platforms with it.
Matthias: It makes me happy that they think using Rust is the obvious choice for their
Matthias: problem. We've come a long way.
Matthias: But with this growth comes great responsibility.
Matthias: Crypto companies are still some of the biggest employers for Rust Talent,
Matthias: although recently they struggled to fill positions as the hype moves on to AI.
Matthias: We're seeing more people put Rust on their CVs, more or less to impress,
Matthias: without the deep understanding that made early Rust developers stand out.
Matthias: It's a natural part of growth, but something we need to be mindful of.
Matthias: Chapter 5. The technical evolution. The technical landscape of Rust looks very
Matthias: different now compared to just a few years ago.
Matthias: Async Rust has matured significantly. The paper cuts that bothered early adopters
Matthias: have mostly been addressed.
Matthias: Tokyo won the runtime wars. Async STD is effectively dead.
Matthias: That's actually good for the ecosystem. Although I personally think structured
Matthias: concurrency and small async runtimes deserve more attention.
Matthias: Many companies now maintain official crates for their use cases.
Matthias: For example, Microsoft maintains an official crate for the Windows API.
Matthias: FFI with Python has improved dramatically. We've gained async closures and async traits in Rust.
Matthias: It has more const capabilities and better compile times. The foundations feel pretty solid.
Matthias: Here's steve again.
Steve: Microsoft is rewriting some legacy windows stuff in rust like gdi the graphics
Steve: drawing interface they have like a port of that to rust stuff and so you know
Steve: there's just there are millions upon millions of rust lines of rust out there
Steve: and being used for real important things,
Steve: if something were to happen to the rust team like it's
Steve: also worth thinking about what would it mean for rust to die okay that
Steve: would mean that the rust team would somehow not exist
Steve: anymore but the code base would still exist of rust itself
Steve: and so like at that point those companies it
Steve: would be an existential threat to their business for that technology to implode and
Steve: so they would have to come up with some alternate way of making
Steve: that work because like you know it can't just
Steve: stop at this point like rust has reached escape velocity
Steve: and is a language that like will survive now is
Steve: it will survive in the sense of like vb.net where
Steve: like it technically exists but not a lot of people use it but like or is it
Steve: a COBOL where like it's used for some things but like not for anything else
Steve: i have no idea if it's that kind of legacy or is it like a c and c plus plus
Steve: where it's used for smaller and smaller amounts of things but still for very
Steve: important things i don't know but it's definitely past the point where it will
Steve: just like disappear at some point because it is just,
Steve: used in too many things that are too meaningful the.
Matthias: Tooling story has some bright spots as well in my opinion ross drover shows
Matthias: promise many of the teams i work for use it as their main ide and it's a fantastic
Matthias: choice because it comes with awesome quality of life features like refactoring
Matthias: capabilities and automatically moving code into modules while fixing the imports.
Matthias: It's always a good sign if other languages copy our ideas as well.
Matthias: For example, result types and pattern matching are commonplace now.
Matthias: But of course we still face challenges. Compile times for large projects remain
Matthias: a constant pain point. Many teams spend significant money on beefy build machines
Matthias: just to keep developer productivity high.
Matthias: And the LLM revolution has changed how people learn Rust.
Matthias: Sure, it helps with the initial hurdles, but I see way too many developers letting
Matthias: LLMs take the wheel and write all their code.
Matthias: This way they miss out on understanding the core patterns that make Rust so unique.
Matthias: My advice is to learn the fundamentals first without LLM assistance.
Matthias: And once you build up that muscle memory, you can use code generation to do the boring part.
Matthias: In the Python ecosystem, Polar's and UV show Rust's disruption potential.
Matthias: Especially Astral's UV is pretty much the standard in the Python ecosystem now,
Matthias: at least in the teams that I talk with.
Matthias: I hope to share more about that in the upcoming seasons.
Matthias: For the first time in a decade, we see some innovation on the VCS front.
Matthias: GitButler and JJ, both written in Rust, challenge the status quo on how we think
Matthias: about source control. and I love how Zed is a snappy new editor written in Rust.
Matthias: Yeah, Rust is known as a performant language but I think that fact is overemphasized
Matthias: outside the Rust community.
Matthias: Rust is just performant by default. The community doesn't really have to try
Matthias: too hard to make Rust code fast.
Matthias: Here's Anton Lazareff from Brave.
Anton: I think what's standing out here is the really nice thing is that I don't even
Anton: have to think about performance when I'm writing the Rust code versus when I
Anton: look at, say, the uBlockOrigin codebase.
Anton: There's so much kind of convolution that happens as a way to squeeze out extra performance.
Anton: And in Rust, I really just don't even have to think about that.
Anton: And it still is competitive.
Matthias: I get firsthand feedback from clients that they want reliable services first
Matthias: and fast services second.
Matthias: Performance almost becomes a side effect of writing reliable software.
Matthias: From what I see, reliability trumps raw speed for most teams.
Matthias: And the Rust compiler makes teams move forward with confidence,
Matthias: as Scott Chacon affirms.
Scott: From the Ruby world, it couldn't be a more different language,
Scott: right? And so I do like the compiler stuff.
Scott: It is nice to be like, most of it is dealing with compiler issues rather than runtime issues.
Scott: So if it compiles and it actually runs something, then it probably runs the way that I meant it to.
Scott: Whereas in Ruby, you don't know until it runs into an issue and there's no good
Scott: debugger and things like that.
Jessie: The language lends itself really well for maintainability and really exactness.
Jessie: There is no time that I'm like, oh, is this going to fail with some random input?
Jessie: It's like, no, you directly define what the input is going to be.
Jessie: And then as long as it's that, you're fine. And it will fail well.
Jessie: I mean, it will air well in the other cases. And so there isn't just this ambiguous,
Jessie: kind of vague definition of things. It's very, very exact.
Jessie: And in the beginning, when you learn the language, that can be off-putting.
Jessie: But I do feel like it's the hugest pro of the language is the exactness of it.
Matthias: That was Jessie Frazelle from Zoo.
Matthias: Chapter 6. Looking Forward Rust 1.85, also known as the Rust 2024 edition, is around the corner.
Matthias: It is set to release on February 20th, 2025.
Matthias: I love that the language gives strong guarantees around backward compatibility.
Matthias: Companies can finally plan long-term migrations.
Matthias: Being able to plan is very important for companies.
Matthias: Enterprise support is important as well, and we're still lagging behind there.
Matthias: But with projects like Ferrocene, we're starting to see a glimpse of what the future might hold.
Matthias: On the language side, I'm excited about some upcoming features.
Matthias: Async trade has finally landed, and generators start to take shape.
Matthias: Letchains will make complex conditional handling more ergonomic.
Matthias: And adding future to the prelude is a clear sign that the sync and async world
Matthias: are gradually coming together.
Matthias: But beyond specific features, I see Rust expanding into new territories.
Matthias: The aviation industry is taking notice.
Matthias: Space tech companies are adopting Rust for mission-critical systems.
Matthias: Healthcare and other highly regulated industries are exploring Rust's safety guarantees.
Matthias: Car manufacturers are building their next-gen user interfaces in Rust.
Matthias: These aren't just plans I know that well-known companies work on such projects
Matthias: internally and some of them have already reached out about sharing their stories in season 4.
Matthias: Keeps me excited after all these years of using Rust.
Matthias: Well, for one, seeing production systems just work is a reward in and of itself.
Matthias: And learning more about how computers work internally and building on top of
Matthias: these solid foundations is just great in and of itself.
Matthias: To me, it's also just using Rust across the entire stack, from low-level systems to web frontends.
Matthias: It's clear to me that we're entering a time of stability, and that's exactly
Matthias: what enterprises need right now.
Matthias: Before we close, we would like to make a few announcements.
Matthias: First off, we'll be at Rust Week. Come say hi if you're there.
Matthias: We'd love to chat about your thoughts on Rust and your current projects.
Matthias: Tickets are still available, and the lineup looks fantastic already.
Matthias: And by the way, we got Rust in production stickers. I want to thank Simon Brüggen
Matthias: for his incredible work editing this show.
Matthias: It's thanks to him that this podcast even exists. His attention to detail and
Matthias: dedication to quality make every episode much, much more enjoyable.
Matthias: We're coming back in April for Season 4 with another fantastic roaster of guests.
Matthias: If your company uses Rust, whether you're a startup or a Fortune 500,
Matthias: reach out. We'd love to hear your story.
Matthias: I rarely ask for this, but if you enjoyed this season, please take the time
Matthias: to rate the podcast on Apple, Spotify, or wherever you listen to your podcasts.
Matthias: Even better, share your favorite episode with a friend or a co-worker.
Matthias: Word of mouth helps us reach more people and bring you more great Rust stories,
Matthias: and that helps the Rust ecosystem grow and prosper.
Matthias: And that's all for today. we hope to see
Matthias: you back in season four rusting production is a podcast by corrode it is hosted
Matthias: by me matthias endler and produced by simon bruggen for show notes transcripts
Matthias: and to learn more about how we can help your company make the most of rust visit
Matthias: corrode.dev thanks for listening,
Matthias: to rusting production.