Speech-to-text transcript of the AutoContent API example "release-notes-to-video" (Whisper large-v3-turbo, not edited; no speaker labels). Welcome back, team. We are looking at a quick, highly pragmatic explainer on the brand new Rust 1.99.0 release today. If you're out there writing reliable, efficient software with Rust, this update is absolutely for you. My goal right now is to get all of us completely up to speed on what actually matters in this release. We're going to cover what's changed, what you should go try out first, and most importantly, what needs your immediate attention when upgrading our codebase. Let's get right into it. here's what we've got on the docket today first upgrading to rust 1.99.0 second an action required warning regarding memory leaking third writing c variadic functions fourth raw pointer layout updates and finally newly stabilized standard apis all right section one upgrading to rust 1.99.0 okay so the crucial thing here is that upgrading is literally as seamless as ever assuming you've already got a previous version installed by a Rustup, all you need to do is pop up in your terminal and run Rustup Update Stable. Boom. That's going to pull down the 1.99.0 release and get you totally ready for development. Now, before we get into the shiny new features, I just want to plant a quick seed for the team. If you want to help test near future releases or, you know, experiment with some cutting edge features before they hit stable, really consider setting up a local environment using the beta channel with Rustup Default Beta, or even the nightly channel with RustUp default nightly. It is a fantastic way to prep our code base for the future and catch any weird bugs early on. Moving right along to section two, action required, memory leaking. Listen up because this is where you need to check your current code base today. The Rust team has updated the docs with a really strong new recommendation against a pattern known as roundtrip unleaking after calling box colon leak. So previously you might have leaked memory using box colon leak, and then later attempted to deallocate that exact same memory. Well, you need to stop doing this. While the actual language semantics haven't fundamentally changed in 1.99.0, this specific pattern has been flagged. Why? Because it has some pretty problematic interactions with current and potential future compiler optimizations. And even more importantly, it's going to be a real headache with the upcoming stabilization of custom allocators. Just a heads up, this guidance applies to other leak functions in the standard library too. So what's the actual action item for us here? Simply put, if you have any logic where you intend to eventually deallocate, you absolutely must avoid Box.leak. Instead, you're going to want to prefer using Box.into non-null or Box.into raw. So do me a favor. Take a few minutes this week to grep your repositories for Box.leak and make sure we aren't setting ourselves up for compiler headaches down the road. Okay, let's get to the fun stuff. Section 3. Writing C-Variatic Functions Now for the new toys. A major stabilization in 1.99.0 is the ability to define C-ABI variatic functions directly using the C and C-Unwind ABIs. Look, we could always call externally defined variatic functions, like C's printf from Rust. That's old news. But with Rust 1.99.0, you can actually write these functions natively in Rust itself. It's awesome. You just use a variable argument list, which you represent by an ellipsis right there in your code, and it'll accept an arbitrary number of arguments. So under the hood, the type represented by that ellipsis is VA list. The really crucial detail here is that VA list is completely ABI compatible with the CVA list type across literally all targets. Plus, to keep things safe, the types that can be read from this list are guarded by the VA arg safe trait. And for those of you on the team doing really low-level systems work, this release also stabilizes support for defining naked variadic functions with non-C ABIs, which you'd write using inline assembly. Honestly, it's a massive win for C interoperability. Raw Pointer Layout Updates Let's briefly touch on some quality-of-life improvements here. The safety requirements for retrieving size and alignment on raw pointers are now fully settled for both sized and non-sized types. Sized types were trivially safe and already possible, sure, but now we have full stabilization across three core functions. Layout for value raw, mem size of val raw, and mem align of val raw. If your code deals heavily with raw memory manipulation, these stabilized functions are absolutely going to make your life noticeably easier. Almost done. Section five, newly stabilized standard APIs. Let's quickly rattle through some newly stabilized standard APIs so you know exactly what's ready for production in our current sprints. Aside from those pointer functions we just talked about, definitely keep an eye out for these. We now have into iterator implementations for boxed arrays, which is incredibly handy. There's vecdeck.retainback and string.fromutf8 lossy-owned. Also highly requested are vec.intoparts and fromparts, which honestly might immediately simplify some of our manual vector data manipulation logic. Oh, and for any file system work, std.fs.setTimes is now fully stable. Definitely check the release notes for the whole list, but these are for sure the standouts that can clean up our code right now. And that wraps up our quick explainer on Rust 1.99.0. As you go and run RustUpUpdate stable this week, I really want you to look closely at your repositories. Ask yourself, is your code base completely clear of that box.leak trap we discussed today? Make those refactors to into-raw or into-non-null a top priority. And hey, once that maintenance is out of the way, what new C-variatic capabilities are you going to build next? Dive into the code and let's put 1.99.0 to work.