Matthias: As we close the chapter on 2025 and celebrate our second year of Rust in Production,
Matthias: it's time to reflect on the highlights of the 17 episodes since our last holiday special.
Matthias: We looked at Rust from all angles, from cloud infrastructure to embedded systems
Matthias: and from robotics to satellite technology.
Matthias: One thing that all of these stories have in common is the passion and dedication
Matthias: of the Rust community to build faster, safer and more reliable software.
Matthias: In this special episode, I want to thank all the guests who shared their experiences
Matthias: and insights with us, as well as our listeners who have supported the podcast throughout the year.
Matthias: Let's look back at some of the
Matthias: memorable moments from the past year and celebrate Rust's achievements.
Matthias: This goes beyond the case studies we've covered. It's about the Rust community
Matthias: as a whole and the state of the Rust ecosystem at the end of 2025.
Matthias: My name is Matthias Endler and you're listening to Rust in Production.
Matthias: Chapter 1. Crossing the Chasm
Matthias: One of the recurring themes in our episodes this
Matthias: year has been the idea of Rust crossing the chasm, from early adopters to mainstream use.
Matthias: This is a significant milestone for any technology.
Matthias: It is also very rare for a programming language to achieve this level of adoption
Matthias: maturity, let alone in such a short time.
Matthias: Rust is no longer a language for enthusiasts and early adopters only.
Matthias: We're seeing more and more companies and projects adopting Rust for mission-critical applications.
Matthias: We've heard how Microsoft mandates Rust for new components in Azure,
Matthias: even going so far as adding it to the Windows kernel.
Matthias: We've heard from Volvo using Rust inside ECUs for their vehicles,
Matthias: and from Prime Video using Rust to power new components in the UI layer of their streaming service.
Matthias: But it's not just large companies. Some of my clients managed to build impressive
Matthias: products with small teams using Rust.
Matthias: I gave a presentation at this year's CodeTalks conference in Hamburg,
Matthias: where I shared a few case studies.
Matthias: For example, how a team of just three developers built a backend service for
Matthias: hundreds of thousands of students in Africa who learn math and English online
Matthias: through low-bandwidth connections.
Matthias: After the service went live, they had zero downtime and were able to scale to meet the demand.
Matthias: The maintenance dropped to almost nothing. All they focus on now is adding new
Matthias: features to help students learn better.
Matthias: Success stories like these are why I love working with Rust.
Matthias: It's hard to convey just how transformative Rust can be for a project until
Matthias: you see it in production.
Matthias: I wish it was easier to demonstrate this to potential new users before they
Matthias: commit to using Rust for their projects.
Matthias: Rust is and will remain a day-two language, and the benefits become more apparent
Matthias: at the later stages of development.
Matthias: That is still a significant barrier to adoption for many teams,
Matthias: as they have to make a leap of faith to trust that Rust will deliver on its promises.
Matthias: That's why as a community, we should not stop telling the stories of Rust in
Matthias: production, the good and the bad, to help other teams make informed decisions
Matthias: on whether Rust is the right choice for them.
Matthias: Speaking of sharing stories, it comes as no surprise that Rust has been named
Matthias: Stack Overflow's most admired language every year since our 1.0 release in 2015.
Matthias: And what people love the most about Rust is the sense of empowerment and versatility it provides.
Matthias: You can write everything from the top to the bottom of your stack in it.
Matthias: Here's Anton Lazarev from Brave.
Anton (Brave): I just feel that Rust solves so many of our problems in software development that we've run into.
Anton (Brave): And it really just works everywhere from embedded to desktop to mobile to even
Anton (Brave): on the web with WebAssembly.
Anton (Brave): I guess my take is that you better have a really good reason not to use Rust
Anton (Brave): as the go-to language for your next project.
Matthias: Julius Gustavsson from Volvo and Charlie Marsh from Astral both echoed this sentiment.
Julius (Volvo): Yeah, empowering is definitely the key word.
Julius (Volvo): We have been super, super happy with this project and it really shows that Rust has a bright future.
Julius (Volvo): The hurdles that we mentioned before when we started the project and which made
Julius (Volvo): it basically a non-starter for most of the ECUs that we wanted to use it,
Julius (Volvo): those are all coming down and or have
Julius (Volvo): come down already so now you have qnx support
Julius (Volvo): for example you have infinium tricore support there
Julius (Volvo): was recently an article on how to run rust
Julius (Volvo): together with autostar classic autostar classic is
Julius (Volvo): the is the common automotive software
Julius (Volvo): framework that most automotive software runs in and now that is becoming available
Julius (Volvo): for for us as well there is work being done on various different automotive
Julius (Volvo): platforms and components so for automotive it's,
Julius (Volvo): definitely a bright future.
Charlie (Astral): It's kind of amazing i think that i only started
Charlie (Astral): writing rust like a few years ago and now we've shipped i mean
Charlie (Astral): along with a great team like we've shipped two of these tools
Charlie (Astral): that are having i i think at least a huge impact on
Charlie (Astral): python which is like the most popular or the second most
Charlie (Astral): popular programming ecosystem on earth so
Charlie (Astral): if you think about it like rust is kind of in a lot
Charlie (Astral): of ways rust is kind of like powering python at least to you
Charlie (Astral): know if i have say about it at least rust is powering is
Charlie (Astral): powering python and so i don't know i've always just
Charlie (Astral): felt i again i never considered myself
Charlie (Astral): to be like a systems programmer quote unquote and most of
Charlie (Astral): my career i was writing typescript python
Charlie (Astral): i mean i did some java professionally but like
Charlie (Astral): i had never except for like a course in
Charlie (Astral): college done any c i really hadn't done any c++ and
Charlie (Astral): like in the span of a few years i like learned
Charlie (Astral): to build this kind of software so i don't
Charlie (Astral): know i've had just like great experiences with the community and and being welcomed
Charlie (Astral): into it and learning the language and i think that's should continue to be a
Charlie (Astral): very important part of of rust is like welcoming people in and helping them
Charlie (Astral): learn because the impact that we can have by building this kind of stuff is
Charlie (Astral): just huge even outside of rust.
Matthias: Finally Andrew Tinka from Scythe highlighted the confidence that Rust gives
Matthias: you when building software.
Andrew (Scythe Robotics): Rust as a language sits at a very valuable point in the language design space.
Andrew (Scythe Robotics): Really is something special in terms of the guarantees it gives,
Andrew (Scythe Robotics): the confidence you can have when building complicated systems with it,
Andrew (Scythe Robotics): knowing that the language has struck such a valuable trade-off between competing
Andrew (Scythe Robotics): concerns of safety and efficiency and expressiveness.
Andrew (Scythe Robotics): It's a technology I'm glad to use every day that I use it, and I hope that its
Andrew (Scythe Robotics): development toward these goals continues as long as it can.
Matthias: And there are few, perhaps no, other languages that can make such bold claims.
Matthias: I certainly struggled in the past when I had to struggle multiple languages
Matthias: for different parts of my projects.
Matthias: Besides navigating different ecosystems and switching contexts,
Matthias: I had to deal with different build systems, package managers,
Matthias: and toolchains. With Rust, I can master one language and use it everywhere.
Matthias: It feels like this is a very common sentiment among our guests.
Matthias: For many, Rust became a gateway into domains that would otherwise be inaccessible,
Matthias: to break down the barriers to entry and make larger parts of the software stack
Matthias: accessible to more people.
Matthias: And when the time comes to integrate Rust into an existing project,
Matthias: it happily takes a backseat to other languages, as it doesn't require a runtime or garbage collector.
Matthias: You can incrementally adopt trust in your codebase one component at a time and
Matthias: gradually leap the benefits.
Matthias: This is a very appealing proposition for many teams who want to slowly and carefully
Matthias: oxidize their codebase without the risk of a complete rewrite.
Matthias: Some of my clients do exactly that to great success.
Matthias: Chapter 2.
Matthias: Fear, Uncertainty, and Doubt It is hard to build systems that must not fail.
Matthias: Or at least do so gracefully.
Matthias: And when Rust fails, it makes the headlines. Many listeners will have heard
Matthias: of the first CVE in Rust for Linux recently.
Matthias: People were up in arms about it, claiming that Rust in the Linux kernel was
Matthias: a mistake, because Rust has bugs too.
Matthias: But if you take a closer look at what actually happened, you will learn that
Matthias: there is no known remote code execution or privilege escalation.
Matthias: Yes, Rust had a bug and crashed the kernel, but it did not lead to a memory safety issue.
Matthias: For context, 159 other CVEs were raised the same day, in the C parts of the kernel.
Matthias: In comparison, Rust had one CVE in five years in an unsafe code block in the
Matthias: implementation of a tricky data structure.
Matthias: That's not perfect, but it's pretty damn close.
Matthias: I often hear people spread the narrative that mistakes can also happen in the
Matthias: Rust compiler and the standard library itself, but fail to acknowledge that
Matthias: a bug in the compiler is a one-time cost that affects all Rust users, and once fixed,
Matthias: will never happen again for anyone rebuilding with the new version of the compiler.
Matthias: Isn't that a massive improvement over other languages?
Matthias: I believe we'll have to live with the fact that there are people who will jump
Matthias: on any opportunity to criticize Rust. It makes for great news headlines.
Matthias: However, I ask you to be critical of the narrative and read past the headlines.
Matthias: On the other hand, when people find bugs in popular software written in C,
Matthias: such as Redis or Curl, the reaction is often that mistakes happen and there is no holy grail.
Matthias: Yes, mistakes happen in every language, but just because there is no silver
Matthias: bullet doesn't mean we shouldn't strive to do better.
Matthias: C and C++ are littered with foot guns and undefined behavior that are impossible
Matthias: to fix without breaking backward compatibility.
Matthias: If you fix a bug in Redis, that fix only applies to Redis, but not to the countless
Matthias: other C programs that are vulnerable to the same issue.
Matthias: As an example, Redis had a remote code execution vulnerability in the Lua interpreter
Matthias: that was enabled by default.
Matthias: The bug was a use-after-free combined with a null-pointer dereference.
Matthias: It went unnoticed for 13 years. In Rust, this code would not compile. In C, it ended in a CVE.
Matthias: If you can't prevent safety issues before they happen, why isn't that a big leap forward?
Matthias: Rust should not be rejected because part of the problem still exists after adopting it.
Matthias: We need to stop comparing actual security problems to an unrealistic,
Matthias: idealized reality where all software is bug-free.
Matthias: While we may never get to 100% bug-free software, we should still adopt the
Matthias: tooling that provably reduces the number of bugs and security vulnerabilities in our codebases today.
Matthias: And no, writing more unit tests or just being more careful when writing C code is not enough.
Matthias: The irony is that teams that adopt Rust often are more rigorous about testing,
Matthias: not less, because their goal of following engineering best practices is what
Matthias: brought them to Rust in the first place.
Matthias: In code reviews and when writing tests, you can focus your testing efforts on
Matthias: the bugs that actually matter and not undefined behavior or memory safety issues.
Matthias: If you put the type system to work, you have more headroom to focus on logic
Matthias: errors and things no compiler can catch.
Matthias: Another popular narrative is that replacing stable C or C++ code with Rust is a waste of time.
Matthias: Why replace perfectly good software that works just fine?
Matthias: But of course, it's not fine, and it's not stable.
Matthias: The myth that C code, once written and working, never changes, is simply not true.
Matthias: For instance, Daniel Stenberg, maintainer of Curl and former guest on this podcast,
Matthias: posted that he's been working on this codebase for more than two decades,
Matthias: and that they get one bug report every three hours.
Matthias: More than half of Curl's source code has been changed within the last four years.
Matthias: Only 1011 lines from before the year 2000 remain untouched.
Matthias: The reality is that programmers continuously rewrite, refactor,
Matthias: and introduce new bugs while doing so. Here's Adam Hendel from Tempo on the topic.
Adam (Tembo): There's really no such thing as finished software or a finished programming language.
Adam (Tembo): It's not like software is distributed in the mail where you burn stuff to a
Adam (Tembo): disk and mail it out, and it just runs that way forever.
Adam (Tembo): Software is living, breathing organisms now, so things have to be constantly fed. it.
Matthias: One of my personal highlights this year was when Jon Seager from Canonical
Matthias: came on the show to talk about their experience shipping a replacement of the
Matthias: GNU core utils in Rust for Ubuntu.
Jon (Canonical): If you've got a really interesting Rust project and you think it's a great fit
Jon (Canonical): for some of the work that we're doing and you want to have a conversation, then reach out.
Jon (Canonical): I'm open to ideas. I don't know all of the high-quality Rust projects out there.
Jon (Canonical): And if there are implementations of things that are very widespread that you
Jon (Canonical): think we should be using, then let me know.
Matthias: Another highlight was Google's update on their Android OS work to integrate Rust into the platform.
Matthias: For the first time ever, memory vulnerabilities fell below 20% of total vulnerabilities thanks to Rust.
Matthias: For reference, the industry norm is around 70%. But their biggest surprise was
Matthias: Rust's impact on software delivery.
Matthias: Rust changes have a four times lower rollback rate.
Matthias: Just imagine the eye-watering cost savings on a platform like Android with 3.9
Matthias: billion active devices worldwide.
Matthias: The safer path is now also faster and more cost-effective.
Matthias: But Rust isn't the right choice for everyone. For instance, we had Richard Feldman
Matthias: on the podcast talking about ROC.
Matthias: His team moved from Rust to SIG for their compiler work, mainly because of slow
Matthias: Rust compile times. And it makes sense.
Matthias: When you're iterating rapidly on a compiler, waiting for Rust to compile can
Matthias: be a real productivity hit. That's a legitimate trade-off.
Matthias: gives you faster iteration at the cost of safety guarantees.
Matthias: For their use case, that made sense.
Matthias: The lesson isn't that Rust failed. It's that different problems need different
Matthias: tools. And that's okay. Let's hear it from Richard himself.
Richard (Roc): Rust is such a big language with so many different features.
Richard (Roc): And there's so many different competing concerns you can have in terms of like,
Richard (Roc): I need to balance like making this safe and also making it well tested and well
Richard (Roc): structured and easy to maintain.
Richard (Roc): There's all these different things that you could be thinking about.
Richard (Roc): And I think focusing on what's the end user going to get out of my program.
Richard (Roc): That's the most important thing. That's got to be the North Star.
Matthias: And even for teams that stuck with Rust, compile times remain a common pain point.
Matthias: Here's Tom Hacohen from Svix and then Alexandru Ene from Prime Video.
Tom (Svix): I think we got to fix the compilation time. I don't know what we can do.
Tom (Svix): It's really, I think it's, it is like a bottleneck for a lot of people.
Tom (Svix): It is, it is a pain and it's, it even affects, you know, like ID,
Tom (Svix): like, you know, language servers and all of that, like when it's,
Tom (Svix): when things are slow. so we got to fix that thing.
Alexandru (Prime Video): One thing I wish we were focusing on more in the ecosystem is build speeds,
Alexandru (Prime Video): like iteration times, just getting those down.
Alexandru (Prime Video): I think right now we more or less accepted that Rust would be slower to compile or whatever.
Alexandru (Prime Video): But I think there's examples out there in other languages where people have gotten great results.
Alexandru (Prime Video): Like Zig, for example, is pushing a lot on the build speed and the iteration
Alexandru (Prime Video): time. And I think we all win if we can iterate in our codes super fast,
Alexandru (Prime Video): like press whatever button you're pressing to run your code.
Alexandru (Prime Video): And if that's like two seconds, it's just magical.
Alexandru (Prime Video): Once it gets past a certain threshold, my productivity just, I get distracted.
Alexandru (Prime Video): So I would just work a lot and investing on, if I were like...
Alexandru (Prime Video): If I had the power to invest in anything in the Rust community,
Alexandru (Prime Video): I would say this would be a really good place to invest in iteration times and
Alexandru (Prime Video): build speed to decrease them.
Matthias: Chapter 3. Outlook for 2026 Rust is here to stay, at least in the Linux kernel.
Matthias: What started as an experiment is now an official part of the project,
Matthias: with Google's binder driver and the Nova GPU driver being some of the most prominent
Matthias: examples of Rust code merged into the mainline kernel this year.
Matthias: As Danilo Krummlich mentioned in his episode, new contributors are excited to
Matthias: work on Rust code in the kernel.
Matthias: We now reached 200 billion downloads of crates from Crates.io this year.
Matthias: 200,000 crates are published and there is no sign of slowing down.
Matthias: The ecosystem is fantastic.
Matthias: The maintainers are working hard to keep up with the growth of the ecosystem
Matthias: and that is highly appreciated.
Matthias: Here's Kevin Guthrie and Edward Wong from Cloudflare.
Edward (Cloudflare): Yeah, no, like we there's a bunch of HTTP ecosystem, things that there's there's
Edward (Cloudflare): a great maintainer for all of it is like open source, the HTTP,
Edward (Cloudflare): literally HTTP crate, H2, you know, a lot of those are our core dependencies for Pingora as well.
Edward (Cloudflare): And the maintainer, Sean is incredible at what he does. so.
Kevin (Cloudflare): Yeah, the thing I was going to thank the Rust community for is for being so coherent,
Kevin (Cloudflare): especially around HTTP things like the hyper ecosystem, the H2,
Kevin (Cloudflare): all of those things are so ubiquitous that it makes integrating with existing projects much easier.
Kevin (Cloudflare): Specifically, I was working with a ClickHouse client that is an official ClickHouse
Kevin (Cloudflare): client that the ClickHouse team puts out, but I needed to add a new feature
Kevin (Cloudflare): for rotating MTLS certificates, which obviously their client does not support.
Kevin (Cloudflare): But because they expose access to the hyper-HTTP client under the hood,
Kevin (Cloudflare): it made it an easy thing to do.
Kevin (Cloudflare): It's just such a good
Kevin (Cloudflare): experience to come to like if you need a feature you already have the tools
Kevin (Cloudflare): necessary to add functionality to tools that are published by other people in
Kevin (Cloudflare): a coherent way something that you don't get in java something that you i don't
Kevin (Cloudflare): know if you get in go that's not my ecosystem but as a former and recovering
Kevin (Cloudflare): java programmer it's very nice the.
Edward (Cloudflare): Ecosystem though i'm sure there are gaps from time to time generally if you
Edward (Cloudflare): are looking for a particular,
Edward (Cloudflare): pattern or thing you will either find out that
Edward (Cloudflare): it is hard to do so or that someone else
Edward (Cloudflare): has already tried to at least some extent to do it and has a working very much
Edward (Cloudflare): like you know if not production ready nearly production ready implementation
Edward (Cloudflare): of it so the rust ecosystem in general has has just been kind of the amount
Edward (Cloudflare): of excitement that folks have within the community,
Edward (Cloudflare): is a great sign of promise.
Matthias: We're also looking forward to a year packed with Rust conferences and meetups around the world.
Matthias: To name the currently announced events, RustNation in London,
Matthias: England on February 18, Rust in Paris, France on March 27, Rustikon in Warsaw,
Matthias: Poland, March 19, RustWeek in Utrecht, the Netherlands, May 18,
Matthias: RustConf from Montreal, Canada, September 8,
Matthias: Oxidize in Berlin, Germany, September 14th, EuroRust in Barcelona,
Matthias: Spain, October 14th, and RustLab in Bologna, Italy on November 1st.
Matthias: Oh, and if you're bored during the holidays, why not code a little Rust?
Matthias: For example, I recently finished recording my Rust HTTP server course for CodeCrafters,
Matthias: and I will link to it in the show notes.
Matthias: Chapter 4. What will Rust 2026 bring us?
Matthias: I personally look forward to Cargo Script, which will allow you to run Rust scripts
Matthias: without the need for a full cargo project.
Matthias: This will make it easier to experiment with Rust and share small,
Matthias: self-contained code snippets.
Matthias: Simon, the editor of this podcast, has been using it heavily over the last year
Matthias: with the nightly releases, and I'm planning to use it for all my future blog posts.
Matthias: The async ecosystem still has some rough edges but i'm confident that we will
Matthias: see steady progress in this area better pin ergonomics could help here.
Vegard (KSAT): I think my primary message to
Vegard (KSAT): the rest community is just polish up
Vegard (KSAT): async get it to be the best
Vegard (KSAT): experience it can ever be there are some pitfalls
Vegard (KSAT): now even though rust 2024 edition stabilized
Vegard (KSAT): the async closures very happy
Vegard (KSAT): about that but there are still some questions around just
Vegard (KSAT): observability of what is happening within an async
Vegard (KSAT): context and how do you navigate that and and just
Vegard (KSAT): yeah and getting to getting to
Vegard (KSAT): the bottom of issues related to to as i said the blocking issues we have and
Vegard (KSAT): just cancellation safety and and drop safety and async drop and all these paper
Vegard (KSAT): cuts that that just are not completely answered yes that that would be my message
Vegard (KSAT): to really polish up that.
Vegard (KSAT): That would make selling Rust to others much easier.
Matthias: That was Vegard Sandengen from KSAT. On top of that, we need even more learning
Matthias: resources for beginner to intermediate and advanced Rust sessions.
Matthias: Andrew Burkhart from 1Password agreed with me on that point in his episode when he said.
Andrew (1Password): Thank you to the Rust community for keeping things open, right?
Andrew (1Password): Like I said, there's so many books out there and the Rust book and the brown
Andrew (1Password): version of the Rust book is amazing with the quizzes and things.
Andrew (1Password): That's all great. I think we also need to continue to or increase how often
Andrew (1Password): we relate to people, right?
Andrew (1Password): Meet people where they're coming from, understanding, you know,
Andrew (1Password): what they do and don't know.
Andrew (1Password): Obviously, with someone coming from my background, that was really critical
Andrew (1Password): that people here did that, you know, and there's a lot of, you know,
Andrew (1Password): acronyms or computer science knowledge. And there's so many people in Rust that are so smart.
Andrew (1Password): It can be difficult. So there's a lot of that that I think we can continue to improve on.
Andrew (1Password): Finding paths to not just go from zero to Rust, which I think we've started
Andrew (1Password): on, or we have a really good path to with the Rust book, or to go from Haskell
Andrew (1Password): to Rust or C++ to Rust or whatever, right?
Andrew (1Password): I think there is a missing middle gap of how do you go from TypeScript to Rust
Andrew (1Password): or this or that, where it's like, I understand variables.
Andrew (1Password): I understand all that. So the whole beginning of Rust book feels boring and getting lost.
Andrew (1Password): And then we go straight into memory or, you know, async and really how async
Andrew (1Password): works. And there are these missing pieces sometimes.
Andrew (1Password): There's things like rustlings, which is incredible for like,
Andrew (1Password): exercise based learning.
Andrew (1Password): But at the end, I didn't see exercise six mesh with exercise 10.
Andrew (1Password): And now I understand that those are two maybe related things.
Andrew (1Password): And so, you know, a lot of people say, right, build stuff, that's that is the greatest way.
Andrew (1Password): But that's not not realistic for everyone. You know, I was working before I
Andrew (1Password): became a developer, I was working, you know, 50, 60 hours a week,
Andrew (1Password): and then, you know, coming home and trying to keep, you know,
Andrew (1Password): my apartment clean and all these things.
Andrew (1Password): And I did not have that much time left to just build things.
Andrew (1Password): It took me a year or more just to try and figure out, you know.
Andrew (1Password): React or whatever it was at the time.
Andrew (1Password): And if it were Rust, I was trying to learn, I had no idea how long it would have taken, you know.
Andrew (1Password): And so I think just finding ways to bridge those gaps and make cohesive learnings
Andrew (1Password): that make concepts actually make sense holistically.
Andrew (1Password): I think that's a really, really huge area that will help a lot of people close the gap of Rust,
Andrew (1Password): which will help Rust adoption you know I've seen that even here where it's like
Andrew (1Password): we may have something we build and go because ramping that team up on rust is
Andrew (1Password): just not feasible in the time frame we have well if there's better resources
Andrew (1Password): to get from go to rust that becomes a non-issue you know and I think we'll see
Andrew (1Password): rust grow the more we are open to bringing people in from more intermediate spaces into rust.
Matthias: Apart from that, my wishlist is pretty short. For the most part,
Matthias: I wish for faster compile times and more clippy lints.
Matthias: My personal hope is that we will see slow and steady growth.
Matthias: The next 10 years aren't guaranteed.
Matthias: Rust's success depends on maintaining the delicate balance between growth and stability.
Matthias: We don't need to be everywhere all at once. We don't need to be a solution to every problem.
Matthias: And we need to bring people along thoughtfully, not hastily.
Matthias: It's important to collaborate with other programming language communities,
Matthias: such as C++, to work on safer interoperability.
Matthias: Work on this has already started. There are billions of lines of C++ code representing
Matthias: trillions of dollars of value stored in C++ codebases.
Matthias: It would be naive to assume that all of this code will be rewritten in Rust
Matthias: anytime soon, so we need to find ways to make Rust and C++ work better together.
Matthias: Let's hear Victor Ciura from Microsoft.
Victor (Microsoft): In order for Rust to succeed,
Victor (Microsoft): C++ does not mean it has to die.
Victor (Microsoft): So it's not a zero-sum game. It's very much about many, many years from now
Victor (Microsoft): where we need to learn to coexist,
Victor (Microsoft): both in terms of software interop and in terms of community interop.
Victor (Microsoft): So I think my message would be, let's spend more time on improving these bridges
Victor (Microsoft): and making sure the languages work well together so that we can successfully
Victor (Microsoft): have these and as communities learn to collaborate better.
Matthias: Other initiatives like BorrowSanitizer, a work-in-progress LLVM instrumentation
Matthias: pass for detecting aliasing violations in multi-language Rust applications, also received funding.
Matthias: I will add a few links in the show notes for those interested in learning more.
Matthias: Looking ahead to 2026, the Rust project has 41 active project goals.
Matthias: 13 of them are designated as flagship goals.
Matthias: They are working on making references more ergonomic, exploring things like
Matthias: field projections, they are making compilation faster with parallel frontend
Matthias: work and build std, they are improving async Rust, but there's still a lot of work to do there.
Matthias: The next generation trade solver is getting closer to being production ready.
Matthias: They're stabilizing Polonius for better borrow checking, getting Rust for Linux
Matthias: into stable Rust by stabilizing the compiler and language features the kernel needs.
Matthias: Let's hear it from Danilo Krummrich from the Linux kernel team.
Danilo (Rust for Linux): When it comes to...
Danilo (Rust for Linux): The things that the kernel needs
Danilo (Rust for Linux): from the Rust project, and there are definitely things that are needed.
Danilo (Rust for Linux): I also want to say thank you for the great collaboration. I'm not that involved myself.
Danilo (Rust for Linux): I definitely want to make that clear. We have other members from the Rust for
Danilo (Rust for Linux): Linux team who are regularly talking to people from the Rust core team and from
Danilo (Rust for Linux): the Rust project in general.
Danilo (Rust for Linux): And there is great collaboration already ongoing.
Danilo (Rust for Linux): So yeah, I'm very happy to see how things go.
Matthias: For a full overview, check out the Rust project goals update on the Rust blog.
Matthias: I will link to it in the show notes.
Matthias: And now we wish you all happy holidays and a prosperous new year filled with
Matthias: safe and reliable software written in Rust.
Matthias: Have fun unwrapping those gifts. It's one of the few times when unwrapping is actually safe to do.
Matthias: Thanks to all our guests for sharing their stories, and to Simon Brüggen,
Matthias: friend, producer, editor, and all-around awesome human being for helping me
Matthias: make this podcast happen.
Matthias: Without Simon, there would be no Rust in production.
Matthias: And lastly, thanks to all of you, our listeners, for tuning in.
Matthias: We would never have believed that a podcast about Rust in production would find
Matthias: such a large and engaged audience.
Matthias: We always love hearing from you.
Matthias: Whether it's via email, social media, or in person at conferences.
Matthias: Greetings to all of you from around the world. We don't ask for it often,
Matthias: but if you enjoy the show, please consider leaving us a review on your favorite podcast platform.
Matthias: It really helps us reach more people and grow the Rust in production community.
Matthias: And if you have a friend or colleague who might enjoy the podcast,
Matthias: please share your favorite episode with them. Word of mouth is still the best
Matthias: way to spread the word about the podcast.
Matthias: I'd like to end with a quote from Nico Matsakis, one of the core members of
Matthias: the Rust team, who I had the pleasure of interviewing earlier this year at RustWeek.
Niko (Rust): Yeah, be excellent to each other. I think Bill and Ted put it best,
Niko (Rust): and I can't do better than that.
Matthias: And with that, we wrap up another year of Rust in production.
Matthias: See you with more stories in 2026.
Matthias: Rust in Production is a podcast by Corode. It is hosted by me,
Matthias: Matthias Endler, and produced by Simon Brüggen.
Matthias: For show notes, transcripts, and to learn more about how we can help your company
Matthias: make the most of Rust, visit corrode.dev.
Matthias: Thanks for listening to Rust in Production.