Rust 1.96.0 Release Breakdown: What Changed in the Standard Library

Added: 2026-06-04

[00:00:00]Hello and welcome back with yet another interesting video on this channel. In this video, we'll do a release review of Rust's latest stable Rust 1.96.0 release as of today, May 28th, 2026 as I'm recording this video. And as always in my release review videos, we'll not just go through the doc, but we'll experience the changes in Rust playground with the latest stable version. So, without further ado, let's dive into it and let's start. Let's start with our first and I would say a big change in this release, which is we have new range types.

[00:00:35]So, ranges are no longer iterators themselves. When I say this, I mean previously when we used to use range one if we used it once, we cannot reuse it because range were iterators and we cannot reuse, but now with the ranges type, that's possible and there are endless other benefits, which we'll see.

[00:00:55]So, let's understand it.

[00:00:58]So, let's say we have a range R and we consume it.

[00:01:02]Let's run this.

[00:01:05]And it works perfectly fine.

[00:01:07]Good enough.

[00:01:08]Let's copy this and let's try to reuse the same range. So, all we are doing is we are trying to reuse the same range again, which is right here. Let's reuse.

[00:01:21]And there you get an error [clears throat] and it says use of moved R because here it was an iterator and it was moved. So, this is one of those problems that we get with the ranges that we had in the prior versions. And now with this release, we have the new core range type. We can define start and end.

[00:01:43]And right here, as you can see, we can literally reuse the range. Now, if I run this, there you go, 0 1 2 3 4 and 0 1 2 3 4.

[00:01:53]So, basically we have the new range, range from and range inclusive And in the near future, we'll see range full and range two. And to summarize, previously, a range carried iteration state and was used up as you iterated over it as we just saw in the example. And this redesign basically separates your data, which is your range, from the iterator or the behavior, making ranges more simpler and flexible to reuse. Again, I would say this is a pretty interesting change. Try it out on your end different other variations that we have, range from, range inclusive, and let me know in the comment what do you think about this change. Now, let's move to the second one, which is assert matching pattern. We have assert matches stable in this release, which basically gives you better control and visibility over a work around, which it was assert matches matches with a macro. Let's understand this with an example as well.

[00:02:51]Previously, if we want to do assert matches, we would do something like this. Assert, and inside, we do matches.

[00:02:58]Now, the problem with this is when it runs, it runs fine, but when it fails, you don't know what exactly is failing.

[00:03:04]So, let's say if I run this, as you can see, the program panicked, but there is not much information on what's wrong.

[00:03:10]What am I getting on left? What am I getting on right? So, there is not a lot of context for you to understand, okay, what's wrong? What should you be fixing it?

[00:03:20]And now, we have assert matches from standard, so we don't need to use any matches macro, and we can directly use assert matches.

[00:03:28]And if I run this, again, when it runs, runs fine, but when it fails, it gives me more context. So, it tells me, okay, left is this, and right is this, and basically, the assertion failed where left is not matching the right. So, basically, I can easily understand looking at it, okay, my X is not greater than 10.

[00:03:51]So, which is something we can understand here. But, if it runs, it runs fine, as we can see right here.

[00:04:01]So, that's the second change which we have, which is assert_matches. Again, try it out on your end and let me know what do you think about this. So, the third change we have is related to WebAssembly target build.

[00:04:12]Basically, WebAssembly targets no longer allow undefined symbols during linking.

[00:04:17]Missing symbols now fail the build instead silently becoming environment imports. So, basically, this helps you catch any misconfigurations and naming bugs earlier at the compile time.

[00:04:29]So, the old behavior you can still restore by using rust flags, but this is something related to your uh WebAssembly builds. Uh possibly, in some future, if we use it in some videos, then I'll, you know, point it out that this is what we talked before.

[00:04:48]But, uh it's really useful if you uh do such kinds of builds. And then, as always, at the end, we have some stabilized APIs. So, as we just discussed, uh assert_matches, debug_assert_matches, and several other core range types are now stable for safer pattern checks and more cleaner range handling.

[00:05:07]Uh so, we also have actually LazyCell, LockCell from impel, and range iter types.

[00:05:13]Improving all basically consistency and I would say economics of the rust ecosystem. So, these are something that we can try it out, but two major things we have two cargo uh vulnerabilities uh which are fixed.

[00:05:27]And that's it for this video, guys. I hope you guys understand something new from this release and try it out on your end and let me know in the comments what do you think about this release. I'll catch you guys in another video with another interesting topic. Until then, bye-bye.