{"version":"https://jsonfeed.org/version/1","title":"Read Rust - All","home_page_url":"https://readrust.net/","feed_url":"https://readrust.net/all/feed.json","description":"All posts.","author":{"name":"Wesley Moore","url":"https://www.wezm.net/"},"items":[{"id":"ad5f1111-0d73-4e39-b196-59820eed781c","title":"Why async Rust?","content_text":"Async/await syntax in Rust was initially released to much fanfare and excitement. Recently, the reception has been a bit more mixed. To some extent this is just the natural progression of the hype cycle, but I also think as we have become more distant from the original design process, some of the context has been lost.","url":"https://without.boats/blog/why-async-rust/","date_published":"2023-10-16T02:53:19Z","author":{"name":"Saoirse"},"tags":["Language"]},{"id":"065deb27-4c94-48dd-8300-dd407753efc0","title":"The Registers of Rust","content_text":"It’s been nearly two and half years since I was an active contributor to the Rust project. There are some releases that I’ve been very excited about since then, and I’m heartened by Niko’s recent blog post emphasizing stability and polish over grand new projects. But I’ve also felt a certain apprehension at a lot of the directions the project has taken, which has often occupied my thoughts. From that preoccupation this blog post has emerged, hopefully the first in a series over the next few weeks outlining my thoughts on the design of Rust in 2023, especially in connection to async, and I hope its impact will be chiefly positive.","url":"https://without.boats/blog/the-registers-of-rust/","date_published":"2023-03-09T00:17:25Z","author":{"name":"Saoirse"},"tags":["Language"]},{"id":"abf2d338-53ff-4fb4-892d-5376798e8649","title":"Reducing code size in librsvg by removing an unnecessary generic struct","content_text":"Someone mentioned cargo-bloat the other day and it reminded me that I have been wanting to measure the code size for generic functions in librsvg, and see if there are improvements to be made.","url":"https://viruta.org/reducing-binary-size-generics.html","date_published":"2023-02-28T04:41:39Z","author":{"name":"Federico Mena Quintero"},"tags":["Performance"]},{"id":"7d1d0b2a-e3a8-4f95-98aa-154305a390a3","title":"Keyword Generics Progress Report: February 2023","content_text":"About 9 months ago we announced the creation of the Keyword Generics Initiative; a group working under the lang team with the intent to solve the function coloring problem through the type system not just for async, but for const and all current and future function modifier keywords as well.\r\n\r\nWe're happy to share that we've made a lot of progress over these last several months, and we're finally ready to start putting some of our designs forward through RFCs. Because it's been a while since our last update, and because we're excited to share what we've been working on, in this post we'll be going over some of the things we're planning to propose.","url":"https://blog.rust-lang.org/inside-rust/2023/02/23/keyword-generics-progress-report-feb-2023.html","date_published":"2023-02-24T00:23:09Z","author":{"name":"Yoshua Wuyts"},"tags":["Language"]},{"id":"0f940b79-bca2-42b9-a22d-5f0f4079356a","title":"Why is building a UI in Rust so hard?","content_text":"In 2019, “GUI” was the 6th most highly requested feature that was preventing adoption of Rust. This is fundamentally a limitation in Rust: the design of the language itself makes modelling common approaches to building UI difficult.\r\n\r\nIn this post, I’ll discuss why Rust’s unique memory management model and lack of inheritance makes traditional techniques to build a UI framework difficult and a few of the ways we’ve been working around it. I believe one of these approaches, or some combination of them, will ultimately lead to a stable cross-platform UI toolkit for high-performance UI rendering that everyone can use.","url":"https://www.warp.dev/blog/why-is-building-a-ui-in-rust-so-hard","date_published":"2023-02-17T00:32:56Z","author":{"name":"Aloke Desai"},"tags":["Language"]},{"id":"0f12e661-08ad-4d52-a0ae-8800e6b1b4c7","title":"New release","content_text":"As you might’ve noticed, the gtk3-rs projects are getting less and less attention and we intend to deprecate them in one of the future releases. Therefore, we recommend to anyone who didn’t upgrade to GTK4 to do it now. gtk3-rs will get further releases in the foreseeable future to keep up with gtk-rs-core, but no development effort is going to be directed towards it. This is already the de-facto situation for more than a year. Additionally, the GTK3 versions of various externally maintained bindings will most likely not get any further releases.\r\n\r\nIn addition to gtk-rs, various externally maintained bindings also had a new release. For gstreamer-rs you can find the CHANGELOG of the 0.20 release here. Most bindings maintained as part of GNOME were also updated.\r\n\r\nOn this note, time to go through the major changes of this release. Enjoy!","url":"https://gtk-rs.org/blog/2023/02/10/new-release.html","date_published":"2023-02-14T03:16:42Z","author":{"name":"gtk-rs devs"},"tags":["Crates"]},{"id":"f1eddadd-ef22-4745-bedb-1c799e4169b4","title":"Rust to WebAssembly the hard way","content_text":"What follows is a brain dump of everything I know about compiling Rust to WebAssembly. Enjoy.\r\n\r\nSome time ago, I wrote a blog post on how to compile C to WebAssembly without Emscripten, i.e. without the default tool that makes that process easy. In Rust, the tool that makes WebAssembly easy is called wasm-bindgen, and we are going to ditch it! At the same time, Rust is a bit different in that WebAssembly has been a first-class target for a long time and the standard library is laid out to support it out of the box.","url":"https://surma.dev/things/rust-to-webassembly/","date_published":"2023-02-14T03:14:19Z","author":{"name":"Surma"},"tags":["Web and Network Services"]},{"id":"ccabda98-0652-4e6a-941c-be824c4e8349","title":"Parsing TFTP in Rust","content_text":"Several years ago I did a take-home interview which asked me to write a TFTP server in Go. The job wasn't the right fit for me, but I enjoyed the assignment. Lately, in my spare time, I've been tinkering with a Rust implementation. Here's what I've done to parse the protocol.","url":"https://tuckersiemens.com/posts/parsing-tftp-in-rust/","date_published":"2023-02-14T03:12:38Z","author":{"name":"Reilly Tucker Siemens"},"tags":["Web and Network Services"]},{"id":"f9045cfc-b30d-42df-8905-6b364a2388f7","title":"Dramatically reducing AccessKit’s memory usage","content_text":"In our recent status update, we called out the use of a single large data structure for all accessible UI elements as a known potential weakness in the design. After that post, feedback from potential users of AccessKit made it clear that this design flaw was a pressing problem that blocked them from using AccessKit. One of these discussions also led us to a particularly attractive technique for solving the problem. So we decided to go ahead and do this optimization work, to unblock further adoption of AccessKit and get the inevitable incompatible API changes out of the way sooner rather than later. This post summarizes the results of this optimization, explains how we did it, and looks ahead to further potential optimizations.","url":"https://accesskit.dev/dramatically-reducing-accesskits-memory-usage/","date_published":"2023-02-09T23:06:10Z","author":{"name":"Matt Campbell"},"tags":["Performance"]},{"id":"229d0cd3-f648-4ec9-addd-f7756bd62d74","title":"The Git source code audit, viewed as a Rust programmer","content_text":"On January 17th 2023, X41 and Gitlab published a report of the source code audit they performed on Git (funded by the OSTIF foundation).\r\n\r\nThis post is based on the (great) report available here and aims to investigate how Rust mitigates some of the vulnerabilities shown in this report, but also to put some light on what it doesn’t mitigate by itself, and how a programmer can address these issues using good practices.","url":"https://litchipi.github.io/infosec/2023/01/24/git-code-audit-viewed-as-rust-programmer.html","date_published":"2023-02-08T23:55:19Z","author":{"name":"Litchi Pi"},"tags":["Security"]},{"id":"6150a064-1abb-490e-b3b0-82c53d881a81","title":"Tauri vs Iced vs egui: Rust GUI framework performance comparison","content_text":"Recently I found myself in need of doing GUI with Rust, so I researched and experimented a bit. In this post, I want to share the data I collected, as it might help others. I will mostly compare Tauri, Iced and egui as those seem to be popular choices. I spent quite a bit of time performing tests to assess the speed/performance of these libraries, as a snappy UI experience is something I really value.","url":"http://lukaskalbertodt.github.io/2023/02/03/tauri-iced-egui-performance-comparison.html","date_published":"2023-02-08T23:49:19Z","author":{"name":"Lukas Kalbertodt"},"tags":["Crates"]},{"id":"8557684f-9c19-432c-a9dd-297ef49f26b9","title":"Rustler - Using Rust crates in Elixir","content_text":"In this blog post, I will show you how easily you can build and use small Rust programs inside Elixir using Rustler.","url":"https://mainmatter.com/blog/2023/02/01/using-rust-crates-in-elixir/","date_published":"2023-02-08T23:19:18Z","author":{"name":"Bartlomiej Dudzik"},"tags":["Language"]},{"id":"9e2a7593-ab69-4fd8-b590-0eaf57aac8a6","title":"Speeding up Rust semver-checking by over 2000x","content_text":"This post describes work in progress: how cargo-semver-checks will benefit from the upcoming query optimization API in the Trustfall query engine. Read on to learn how a modern linter works under the hood, and how ideas from the world of databases can improve its performance.","url":"https://predr.ag/blog/speeding-up-rust-semver-checking-by-over-2000x/","date_published":"2023-02-07T23:13:25Z","author":{"name":"Predrag Gruevski"},"tags":["Performance"]},{"id":"4f6bd9d4-aa60-4c84-a5cf-4559f18432ff","title":"Generate gem skeleton with Rust extension","content_text":"Do you think dynamically typed interpreted Ruby language and statically typed compiled Rust language could be friends? Yes, they can! And actually, they are!\r\n\r\nOfficially it all started when YJIT was ported to Rust and Ruby codebase has officially onboarded Rust code. This friendship matured when RubyGems 3.3.11 (with a new Add cargo builder for rust extensions feature) was released capable of compiling Rust-based extensions during gem installation process (similar to well-known C-based gem extensions like nokogiri, pg or puma).\r\n\r\nAnd now, with Bundler 2.4, bundle gem skeleton generator can provide all the glue you need to start using Rust inside your gems thanks to the new --ext=rust parameter!","url":"https://bundler.io/blog/2023/01/31/rust-gem-skeleton.html","date_published":"2023-02-06T22:10:31Z","author":{"name":"Josef Šimánek"},"tags":["Language"]},{"id":"d49b2e63-eaa2-41c5-8825-98e41765f36f","title":"Exploring Rust for Vulkan drivers, part 1","content_text":"Over the course of the last decade, Rust has emerged as a new programming language for writing safe low-level code. I've been contemplating the idea of using it in Mesa for a few years now. Specifically, I'd like to know if it's practical to write a Vulkan driver mostly in Rust and if doing so would bring enough benefit to be worth the effort. This blog post is intended to be the first in a series exploring the area of using Rust to write Mesa Vulkan drivers.","url":"https://www.collabora.com/news-and-blog/blog/2023/02/02/exploring-rust-for-vulkan-drivers-part-1/","date_published":"2023-02-06T22:08:07Z","author":{"name":"Faith Ekstrand"},"tags":["Games and Graphics"]},{"id":"41244323-fb74-4346-ad4a-3966ff71fccb","title":"The size of Rust Futures","content_text":"I have recently discovered that Rust Futures, or rather, async fn calls can lead to surprising performance problems if they are nested too deeply.\r\n\r\nApart from highlighting the source of the problem in great depth, I also want to propose some workarounds for this specific issue.","url":"https://swatinem.de/blog/future-size/","date_published":"2023-01-29T22:15:21Z","author":{"name":"Arpad Borsos"},"tags":["Performance"]},{"id":"b8e2fbb2-3e66-4354-853a-ef6f9c63689b","title":"Testing SIMD instructions on ARM with Rust on Android","content_text":"This blog post is the last one of a series exploring SIMD support with Rust on Android. In the previous two posts, I introduced how to compile Rust libraries for Android and detect SIMD instructions supported by the CPU at runtime.\r\n\r\nToday, we’ll see how to effectively use the SIMD instructions themselves, and get the most performance out of them. After an introduction on running Rust benchmarks (and unit tests) on Android devices, we’ll measure the performance in various scenarios offered by Rust, and see that the overhead of CPU feature detection can be non-trivial. I’ll then describe various ways to reduce this overhead.\r\n\r\nLastly, I’ll present updated benchmarks on ARM of Horcrux, my Rust implementation of Shamir’s Secret Sharing, and see how they compare to Intel.","url":"https://gendignoux.com/blog/2023/01/05/rust-arm-simd-android.html","date_published":"2023-01-19T23:23:17Z","author":{"name":"Guillaume Endignoux"},"tags":["Performance"]},{"id":"0566eee6-4ef9-4bf5-8d25-27adf2de77f2","title":"Running Zola on WebAssembly","content_text":"Even though Zola is written in Rust, it still relies on glibc, the GNU C Library. The update to v15 changed how the Zola binary for Linux was built, causing it to rely on newer versions of glibc. After a few emails with Vercel's support team, I confirmed that the build environment used by Vercel only had access to glibc 2.26, hence the errors when attempting to use the latest version of Zola.\r\n\r\nNow, at this point, I had a few options if I wanted to use the latest version of Zola to build my site, but the easiest was probably setting up my Vercel project to download a custom-built version of Zola that was built against a lower version of glibc. While it certainly would have worked, and wouldn't have been too much effort, it also wasn't a fun or interesting solution.\r\n\r\nInstead, I decided to see if I could compile Zola to WASM targeting the WebAssembly System Interface (WASI) and run it as a standard npm package.\r\n\r\nSpoiler: I could!","url":"https://dstaley.com/posts/running-zola-on-wasm/","date_published":"2023-01-13T06:57:10Z","author":{"name":"Dylan Staley"},"tags":["Web and Network Services"]},{"id":"c3b3af65-121a-43f1-a42f-e258240b5bff","title":"Supporting the Use of Rust in the Chromium Project","content_text":"We are pleased to announce that moving forward, the Chromium project is going to support the use of third-party Rust libraries from C++ in Chromium. To do so, we are now actively pursuing adding a production Rust toolchain to our build system. This will enable us to include Rust code in the Chrome binary within the next year. We’re starting slow and setting clear expectations on what libraries we will consider once we’re ready.\r\n\r\nIn this blog post, we will discuss how we arrived at the decision to support third-party Rust libraries at this time, and not broader usage of Rust in Chromium. ","url":"https://security.googleblog.com/2023/01/supporting-use-of-rust-in-chromium.html","date_published":"2023-01-12T22:10:09Z","author":{"name":"Dana Jansens"},"tags":["Web and Network Services"]},{"id":"188d3002-88c7-4099-8b84-465e9b2cc863","title":"gccrs in 2022","content_text":"The most notable event occuring this year was the merging of gccrs into GCC. Our compiler will now be available in the next GCC release, GCC 13.1, due in April 2023. While the compiler is not yet complete, or even in a usable state, we hope you’ll find joy in experimenting with it, hacking on it, and contributing, either via reporting issues or submitting code.\r\n\r\nWe have attended multiple events, and were delighted to meet so many of you! We are looking forward to doing the same in 2023. Later in this report, you’ll find links to recordings of the talks we gave this year.\r\n\r\nEven further in the report, you’ll find various little statistics around the compiler’s development: Number of bugs, ongoing work, number of tests… We don’t see the amount of bugs almost doubling since 2021 as a bad thing: quite the opposite actually, as it means the compiler is being tested more and more thoroughly, and used by more and more brave people willing to raise these issues. For that, thank you!","url":"https://rust-gcc.github.io/reporting/2022-year-report.html","date_published":"2023-01-11T02:39:16Z","author":{"name":"gccrs"},"tags":["Tools and Applications"]},{"id":"eb7a2a41-69e7-42a8-b250-ede88433f9bb","title":"What Every Rust Developer Should Know About Macro Support in IDEs","content_text":"We, the IntelliJ Rust plugin team, are now partially enabling support for procedural macros, specifically enabling function-like and derive procedural macro expansion by default while hiding support for attribute procedural macros behind the org.rust.macros.proc.attr experimental feature flag. While we mostly refer to the IntelliJ Rust plugin here, the same things apply to your favorite editor powered by rust-analyzer. In fact, we are very similar regarding macro support. Even more importantly, we face the same problems.\r\n\r\nLet’s discuss several fundamental ideas regarding macros and their support in IDEs, including main ideas and approaches, good and bad parts, implementation details, and problems.","url":"https://blog.jetbrains.com/rust/2022/12/05/what-every-rust-developer-should-know-about-macro-support-in-ides/","date_published":"2023-01-07T04:37:45Z","author":{"name":" Vitaly Bragilevsky "},"tags":["Tools and Applications"]},{"id":"9d56dab2-f727-4758-8bc9-3f6270126c39","title":"Is coding in Rust as bad as in C++?","content_text":"C++ is notorious for its slow build times. “My code's compiling” is a meme in the programming world, and C++ keeps this joke alive.\r\n\r\nI've heard the same thing about Rust: build times are a huge problem. But is it really a problem in Rust, or is this anti-Rust propaganda? How does it compare to C++'s build time problem? ","url":"https://quick-lint-js.com/blog/cpp-vs-rust-build-times/","date_published":"2023-01-07T04:33:31Z","author":{"name":"strager"},"tags":["Performance"]},{"id":"58856648-c800-41fe-a863-0fc0b23a4b08","title":"Announcing KataOS and Sparrow","content_text":"To begin collaborating with others, we've open sourced several components for our secure operating system, called KataOS, on GitHub, as well as partnered with Antmicro on their Renode simulator and related frameworks. As the foundation for this new operating system, we chose seL4 as the microkernel because it puts security front and center; it is mathematically proven secure, with guaranteed confidentiality, integrity, and availability. Through the seL4 CAmkES framework, we're also able to provide statically-defined and analyzable system components. KataOS provides a verifiably-secure platform that protects the user's privacy because it is logically impossible for applications to breach the kernel's hardware security protections and the system components are verifiably secure. KataOS is also implemented almost entirely in Rust, which provides a strong starting point for software security, since it eliminates entire classes of bugs, such as off-by-one errors and buffer overflows.\r\n","url":"https://opensource.googleblog.com/2022/10/announcing-kataos-and-sparrow.html","date_published":"2022-12-22T04:17:11Z","author":{"name":"Sam, Scott, and June"},"tags":["Operating Systems"]},{"id":"5f6a9b4c-0ca3-4124-954d-973ed77953c1","title":"Rust 2023","content_text":"The core team used to put out a yearly call for blog posts. My colleage Nick published their \"Rust in 2023\" post last week, and encouraged others to do the same. I like the idea of taking a moment to reflect on larger topics, and so well, why not write a post!","url":"https://blog.yoshuawuyts.com/rust-2023/","date_published":"2022-12-21T22:51:56Z","author":{"name":"Yoshua Wuyts"},"tags":["Language"]},{"id":"5040f17c-6e1a-4e9f-9d49-df26723e5947","title":"Ten Years of Ru...ewriting my website","content_text":"December 21 is the anniversary of when I first heard about Rust way back in 2012. I used to write yearly posts about it; the last time I did was in 2018. That makes today ten years. I thought I’d have something big to say here, but… I just don’t.","url":"https://steveklabnik.com/writing/ten-years-of-ru---ewriting-my-website","date_published":"2022-12-21T22:45:25Z","author":{"name":"Steve Klabnik"},"tags":["Language"]},{"id":"b7c04bb9-6916-4ab5-a313-7691f27476e1","title":"Building a Rust-y Vim clutch with the Raspberry Pi 2040","content_text":"Sadly my time working with a colleague had come to an end and I wanted to give him a token of my appreciation. In these days of hybrid working, I thought what better way to show my appreciation to an infrequent Vim user, than to add another rarely useful peripheral to their bag!","url":"https://blog.scottlogic.com/2022/12/08/building-a-rusty-vim-clutch.html","date_published":"2022-12-09T03:31:14Z","author":{"name":"Chris Price"},"tags":["Embedded"]},{"id":"54724890-2c04-40de-8a78-ae56ef4a47dc","title":"This Month in Rust OSDev: November 2022","content_text":"Welcome to a new issue of \"This Month in Rust OSDev\". In these posts, we give a regular overview of notable changes in the Rust operating system development ecosystem.\r\n\r\nWe have some new sections this month, we hope you like the content!","url":"https://rust-osdev.com/this-month/2022-11/","date_published":"2022-12-07T23:07:22Z","author":{"name":"Philipp Oppermann"},"tags":["Operating Systems"]},{"id":"ec35d584-970b-498e-9cca-e6aa4e0bb32f","title":"Helix Release 22.12 Highlights","content_text":"Helix is a modal text editor with built-in support for multiple selections, Language Server Protocol (LSP), tree-sitter, and experimental support for Debug Adapter Protocol (DAP).\r\n\r\nToday we cut the 22.12 release. This release is big and featureful and saw contributions from 99 contributors. Thank you all! 🎊","url":"https://helix-editor.com/news/release-22-12-highlights/","date_published":"2022-12-07T06:48:02Z","author":{"name":"Michael Davis"},"tags":["Tools and Applications"]},{"id":"0744dc9d-fff8-42c9-a501-13da0a163a5f","title":"KernelCI now testing Linux Rust code","content_text":"During the 2022 Linux Maintainers Summit in Dublin, Linus Torvalds asked CI systems to start testing the new Rust infrastructure. So, with that in mind, we are excited to announce that as of today, Rust testing has now been added to KernelCI!","url":"https://www.collabora.com/news-and-blog/news-and-events/kernelci-now-testing-linux-rust-code.html","date_published":"2022-12-06T21:46:36Z","author":{"name":"Adrian Ratiu"},"tags":["Operating Systems"]},{"id":"9341163a-cd14-4461-b6dc-3be5e18e56ec","title":"Launching the 2022 State of Rust Survey","content_text":"It's that time again! Time for us to take a look at who the Rust community is composed of, how the Rust project is doing, and how we can improve the Rust programming experience. The Rust Survey working group is pleased to announce our 2022 State of Rust Survey! Whether or not you use Rust today, we want to know your opinions. Your responses will help the project understand its strengths and weaknesses, and establish development priorities for the future.","url":"https://blog.rust-lang.org/2022/12/05/survey-launch.html","date_published":"2022-12-06T13:51:16Z","author":{"name":"The Rust Survey Working Group"},"tags":["Community"]},{"id":"971221f9-353b-4572-802e-58d8d2209c92","title":"Memory Safe Languages in Android 13","content_text":"For more than a decade, memory safety vulnerabilities have consistently represented more than 65% of vulnerabilities across products, and across the industry. On Android, we’re now seeing something different - a significant drop in memory safety vulnerabilities and an associated drop in the severity of our vulnerabilities. This drop coincides with a shift in programming language usage away from memory unsafe languages. Android 13 is the first Android release where a majority of new code added to the release is in a memory safe language.","url":"https://security.googleblog.com/2022/12/memory-safe-languages-in-android-13.html?m=1","date_published":"2022-12-01T23:12:20Z","author":{"name":"Jeffrey Vander Stoep"},"tags":["Operating Systems"]},{"id":"3b5f9d9b-498c-4b45-8a48-c8336d9d4509","title":"Out-of-bounds memory access bug","content_text":"Recent fuzz testing has uncovered a bug in capnproto-rust and capnproto-c++ that allows out-of-bounds memory to be accessed in certain situations.","url":"http://dwrensha.github.io/capnproto-rust/2022/11/30/out_of_bounds_memory_access_bug.html","date_published":"2022-11-30T23:20:03Z","author":{"name":"David Renshaw"},"tags":["Security"]},{"id":"7e47217c-f251-4094-8cce-207263dd5071","title":"Fedora 38 Looks To Shift RPM To Sequoia, A Rust-Based OpenPGP Parser","content_text":"For the past two decades the RPM package manager software has relied upon its own OpenPGP parser implementation for dealing with package keys and signatures. With Fedora 38 they plan to have their RPM package shifted to use the Rust-written \"Sequoia\" parser instead. ","url":"https://www.phoronix.com/news/Fedora-38-RPM-Sequoia-Rust","date_published":"2022-11-30T23:14:06Z","author":{"name":"Michael Larabel"},"tags":["Operating Systems","Security"]},{"id":"35c94deb-6622-4243-9d90-3ef4bbd425b2","title":"How much does Rust's bounds checking actually cost?","content_text":"Rust prevents out-of-bounds memory accesses and buffer overruns via runtime bounds checks - what’s the cost of those bounds checks for a real-world, production application?","url":"https://blog.readyset.io/bounds-checks/","date_published":"2022-11-30T23:12:51Z","author":{"name":"Griffin Smith"},"tags":["Performance"]},{"id":"1c3b0c68-19f1-4862-a78c-871c72af49c5","title":"Safely writing code that isn't thread-safe","content_text":"One of the nice things about the Rust programming language is that it makes it easier to write correct concurrent (e.g. threaded) programs – to the degree that Rust’s slogan has been, at times, “fearless concurrency.”\r\n\r\nBut I’d like to tell you about the other side of Rust, which I think is under-appreciated. Rust enables you to write programs that are not concurrent. This feature is missing from most other languages, and is a source of much complexity and bugs.","url":"http://cliffle.com/blog/not-thread-safe/","date_published":"2022-11-25T00:09:03Z","author":{"name":"Cliff L. Biffle"},"tags":["Performance"]},{"id":"83a08a71-eba7-4145-8dc8-5ee97b762a37","title":"Rust developers can now generate consistent type schema with Typeshare","content_text":"Today, 1Password is making Typeshare publicly available as an open-source project to help Rust developers generate consistent type schema across multiple languages.\r\n\r\nDecoupling the display code from our business logic gives us cross-platform consistency while also letting 1Password look great on any device. But the frontends are written in a different language, so we use a foreign function interface to communicate with the frontends.\r\n\r\nBut we needed to ensure the data we gave to the frontend was understood correctly - if the data types between the languages weren’t in sync, it would result in a host of problems. Typeshare was the solution, and today it helps our backend developers rapidly develop new features and fixes without fear of breaking consistency with our display code.","url":"https://blog.1password.com/typeshare-for-rust/","date_published":"2022-11-24T00:27:11Z","author":{"name":"Jason Harris"},"tags":["Crates"]},{"id":"ce819810-d360-42fa-95ea-8002a28a9952","title":"Redox OS 0.8.0","content_text":"We have a lot to show since the 0.7.0 release! This release, care has been taken to ensure real hardware is working, i686 support has been added, features like audio and preliminary multi-display support have been enabled, and the boot and install infrastructure has been simplified and made more robust. I highly recommend skimming through the changes listed below before jumping into the images, if you want more details.","url":"https://www.redox-os.org/news/release-0.8.0/","date_published":"2022-11-24T00:01:28Z","author":{"name":"Jeremy Soller"},"tags":["Operating Systems"]},{"id":"5264085c-34f9-46a0-953b-dabedabbab23","title":"Flux: Refinement Types for Rust","content_text":"Types bring order to code. For example, if a variable i:usize then we know i is a number that can be used to index a vector. Similarly, if v:vec<&str> then we can be sure that v is a collection of strings which may be indexed but of course, not used as an index. However, by itself usize doesn’t tell us how big or small the number and hence the programmer must still rely on their own wits, a lot of tests, and a dash of optimism, to ensure that all the different bits fit properly at run-time.\r\n\r\nRefinements are a promising new way to extend type checkers with logical constraints that specify additional correctness requirements that can be verified by the compiler, thereby entirely eliminating various classes of run-time problems.\r\n\r\nWe’re excited to introduce Flux, a refinement type checker plugin that brings this technology to Rust.","url":"https://liquid-rust.github.io/2022/11/14/introducing-flux/","date_published":"2022-11-22T23:10:28Z","author":{"name":"Ranjit Jhala"},"tags":["Computer Science"]},{"id":"2106efb4-341b-429d-a321-d68ee87ef026","title":"The carcinization of Go programs","content_text":"What if I told you there was a way that we could ship one binary from Rust, have that work on every platform Go supports, and not have to modify the build process beyond a simple go build? Imagine how much easier that would be. It's easy to imagine that such a thing would let users not even know that Rust was involved at all, even if they consume a package or program that uses it.\r\n\r\nI've done this with a package I call mastosan and here's why it exists as well as how I made it.","url":"https://xeiaso.net/blog/carcinization-golang","date_published":"2022-11-22T23:06:11Z","author":{"name":"Xe Iaso"},"tags":["Language"]},{"id":"6968d706-d96b-4b22-88a1-54cab54a5a45","title":"From AST to bytecode execution in EndBASIC","content_text":"Since its inception two years ago, the EndBASIC interpreter has been using an AST-based execution\r\nengine. And during all this time, people have mocked the language for not allowing 10 GOTO 10.\r\nWell, fear not: the upcoming 0.10 release has full support for GOTO and GOSUB, features that\r\nwere made possible by moving to a bytecode-based interpreter. Let’s take a peek at what the\r\nproblems were and how I addressed them.","url":"https://jmmv.dev/2022/11/endbasic-bytecode.html","date_published":"2022-11-22T22:38:48Z","author":{"name":"Julio Merino"},"tags":["Tools and Applications"]},{"id":"6ea0da68-3b93-4111-be92-641bb9159f80","title":"A first look at Rust in the 6.1 kernel","content_text":" There have been a lot of significant changes merged into the mainline for the 6.1 release, but one of the changes that has received the most attention will also have the least short-term effect for users of the kernel: the introduction of support for the Rust programming language. No system with a production 6.1 kernel will be running any Rust code, but this change does give kernel developers a chance to play with the language in the kernel context and get a sense for how Rust development feels. Perhaps the most likely conclusion for most developers, though, will be that there isn't yet enough Rust in the kernel to do much of anything interesting.","url":"https://lwn.net/Articles/910762/","date_published":"2022-10-31T23:37:44Z","author":{"name":"Jonathan Corbet"},"tags":["Operating Systems"]},{"id":"e3507c8b-0d53-4319-8a51-a3e8d1f7fab5","title":"Generic associated types to be stable in Rust 1.65","content_text":"As of Rust 1.65, which is set to release on November 3rd, generic associated types (GATs) will be stable — over six and a half years after the original RFC was opened. This is truly a monumental achievement; however, as with a few of the other monumental features of Rust, like async or const generics, there are limitations in the initial stabilization that we plan to remove in the future. \r\n\r\nThe goal of this post is not to teach about GATs, but rather to briefly introduce them to any readers that might not know what they are and to enumerate a few of the limitations in initial stabilization that users are most likely to run into.","url":"https://blog.rust-lang.org/2022/10/28/gats-stabilization.html","date_published":"2022-10-29T03:16:23Z","author":{"name":"Jack Huey"},"tags":["Language"]},{"id":"a3124dcd-6c7d-4312-9a40-dab084b54277","title":"Evaluating Build Scripts in the IntelliJ Rust Plugin","content_text":"Build scripts is a Cargo feature that allows executing any code prior to building a package. We implemented support for build scripts evaluation in the IntelliJ Rust plugin a long time ago, but up until now, we hid it under the org.rust.cargo.evaluate.build.scripts experimental feature. As we are now enabling this feature by default, we’ve decided to explain what it means for our users.","url":"https://blog.jetbrains.com/rust/2022/10/24/evaluating-build-scripts-in-the-intellij-rust-plugin/","date_published":"2022-10-25T09:55:22Z","author":{"name":"Vitaly Bragilevsky"},"tags":["Tools and Applications"]},{"id":"57c5a854-aa88-4a4e-9ffd-ea5d07b63059","title":"Progress report on rustc_codegen_cranelift (Okt 2022)","content_text":"There has a ton of progress since the last progress report. There have been 303 commits since then. @afonso360 has been contributing a ton to improve Windows and AArch64 support. (Thanks a lot for that!)","url":"https://bjorn3.github.io/2022/10/12/progress-report-okt-2022.html","date_published":"2022-10-21T00:38:58Z","author":{"name":"bjorn3"},"tags":["Language"]},{"id":"5947eca8-807e-4389-bd45-6cea646303c0","title":"Rust on Espressif chips - 17-10-2022","content_text":"This is the next quarterly update of esp-rs effort, detailing the progress over Q3 2022.","url":"https://mabez.dev/blog/posts/esp-rust-17-10-2022/","date_published":"2022-10-21T00:36:58Z","author":{"name":"Scott Mabin"},"tags":["Embedded"]},{"id":"1b831865-6b0e-40ad-aaa1-fad74c579eb3","title":"A deeper look into the GCC Rust front-end","content_text":"Philip Herron and Arthur Cohen presented an update on the \"gccrs\" GCC front end for the Rust language at the 2022 Kangrejos conference. Less than two weeks later — and joined by David Faust — they did it again at the 2022 GNU Tools Cauldron. This time, though, they were talking to GCC developers and refocused their presentation accordingly; the result was an interesting look into the challenges of implementing a compiler for Rust.","url":"https://lwn.net/Articles/909887/","date_published":"2022-10-21T00:25:01Z","author":{"name":"Jonathan Corbet"},"tags":["Language"]},{"id":"d00f607a-dd9a-439f-b575-4a3e8fc84bba","title":"RAII: Compile-Time Memory Management in C++ and Rust","content_text":"One of the biggest such features – perhaps the biggest one – is RAII, C++’s and now Rust’s (somewhat oddly-named) scope-based feature for resource management. And while RAII is for managing all kinds of resources, its biggest use case is as part of a compile-time alternative to run-time garbage collection and reference counting.\r\n\r\nI will start by talking about the problem that RAII was originally designed to solve. Then, I will re-hash the basics of how RAII works, and work through memory usage patterns where RAII needs to be combined with these other features, especially the borrow checker. Finally, I will discuss the downsides of these memory management techniques, especially performance implications and handling of cyclic data structures.","url":"https://www.thecodedmessage.com/posts/raii/","date_published":"2022-10-21T00:21:38Z","author":{"name":"Jimmy Hartzell"},"tags":["Language"]},{"id":"99d096b8-5b53-4197-9327-543c4f60eefd","title":"Welcoming Sage Griffin: Rust Foundation Communities Advocate","content_text":"The Rust Foundation could not adequately support the Rust programming language and the maintainers developing the project without a strong focus on community health and collaboration. For this reason, we’ve been seeking to fill a significant role at the Foundation for several months. \r\n\r\nToday, we’re thrilled to share that Sage Griffin has joined the Rust Foundation as our first Communities Advocate. Sage uses they/them pronouns.","url":"https://foundation.rust-lang.org/news/welcoming-sage-griffin-rust-foundation-communities-advocate/","date_published":"2022-10-19T23:06:59Z","author":{"name":"The Rust Foundation"},"tags":["Community"]},{"id":"12031226-3824-485f-8e60-cf2824bd1f2c","title":"retrowin32, a win32 emulator","content_text":"My first post-Figma hobby project is a win32 emulator I've called retrowin32. It is now barely capable of executing a few unmodified Windows exe files in a browser (see the site for some links).\r\n\r\nThere are other projects to run old Windows programs. WoW64 is the name of the system within 64-bit Windows that makes old 32-bit Windows programs run. Wine shims the Windows API onto your host system — see the great How Wine works for a deep dive on what that means. And system emulator projects like qemu emulate a full x86 machine such that you can install Windows onto them. But Wow64 requires running 64-bit Windows, Wine requires x86 hardware, and qemu requires installing the full Windows OS into the emulator to run a Windows program.\r\n\r\nIn contrast, my toy emulates an x86 and enough of the Windows API to take a plain exe file and run it directly in my browser.","url":"https://neugierig.org/software/blog/2022/10/retrowin32.html","date_published":"2022-10-15T02:03:35Z","author":{"name":"Evan Martin"},"tags":["Operating Systems"]},{"id":"dd057b1e-49e8-4f67-a94a-7b170b941bb0","title":"A Memory Safe Implementation of the Network Time Protocol","content_text":"For the last few months we at Tweede golf have been working on implementing a Network Time Protocol (NTP) client and server in rust.\r\n\r\nThe project is a Prossimo initiative and is supported by their sponsors, Cisco and AWS. Our first short-term goal is to deploy our implementation at Let's Encrypt. The long-term goal is to develop an alternative fully-featured NTP implementation that can be widely used.\r\n\r\nIn this blog post we'll talk about the process of implementing a new open-source version of the protocol in Rust, why an alternative NTP implementation is important, and our experiences along the way.","url":"https://www.memorysafety.org/blog/memory-safe-ntp/","date_published":"2022-10-14T00:33:29Z","author":{"name":"Folkert de Vries"},"tags":["Web and Network Services"]},{"id":"86cf9687-80b8-41d5-bcc6-6a2231cf6167","title":"Hard Mode Rust","content_text":"This post is a case study of writing a Rust application using only minimal, artificially constrained API (eg, no dynamic memory allocation). It assumes a fair bit of familiarity with the language.","url":"https://matklad.github.io//2022/10/06/hard-mode-rust.html","date_published":"2022-10-06T23:20:21Z","author":{"name":"Aleksey Kladov"},"tags":["Language"]},{"id":"2cbf053c-03f7-4e9c-86a5-97ef38863934","title":"An Invitation to Rust Maintainers","content_text":"A few weeks ago, we at Determinate Systems released Riff, a tool that uses Nix to automatically provide external dependencies for Rust projects. By that we mean dependencies written in other languages—like OpenSSL or the Protobuf compiler—that by definition can’t be installed by Cargo. The developer experience of Rust is widely regarded as one of the best in the business—and we concur!—but external dependencies have been a thorn in the side of the Rust community from the get-go. And so we’re excited to provide a full-fledged solution to this problem in the form of Riff.","url":"https://determinate.systems/posts/riff-rust-maintainers","date_published":"2022-10-06T06:35:34Z","author":{"name":"Luc Perkins"},"tags":["Tools and Applications"]},{"id":"951018d2-70d3-4d3d-90d8-2a94cf1e0b07","title":"Single Pass Recursion in Rust","content_text":"This is the third post in a three-post series. In the first post we developed a stack-safe, ergonomic, and concise method for working with recursive data structures (using a simple expression language as an example). In the second post we made it fully generic, providing a set of generic tools for expanding and collapsing any recursive data structure in Rust.\r\n\r\nIn this post we will see how to combine these two things - expanding a structure and collapsing it at the same time, performing both operations in a single pass. In the process, we will gain the ability to write arbitrary recursive functions over traditional boxed-pointer recursive structures (instead of the novel `RecursiveTree` type introduced in my previous post) while retaining stack safety.","url":"https://recursion.wtf/posts/rust_schemes_3/","date_published":"2022-10-06T06:31:19Z","author":{"name":"Inanna Malick"},"tags":["Computer Science"]},{"id":"079afbb0-f41f-4c24-841b-e9269ceaa880","title":"zerocal - A Serverless Calendar App in Rust Running on shuttle.rs","content_text":"Like any reasonable person, I wanted a way to create calendar entries from my terminal.\r\n\r\nThat's how I pitched the idea to my buddies last time. The answer was: \"I don’t know, sounds like a solution in search of a problem.\" But you know what they say: Never ask a starfish for directions.\r\n\r\nThat night I went home and built a website that would create a calendar entry from GET parameters.","url":"https://endler.dev/2022/zerocal/","date_published":"2022-10-05T22:03:42Z","author":{"name":"Matthias Endler"},"tags":["Web and Network Services"]},{"id":"a8b1fc93-d40e-4657-bc5c-4be74900d017","title":"Implementing truly safe semaphores in rust, and the costs we pay for safety","content_text":"A couple of weeks ago, we released an update to rsevents, our crate that contains a rusty cross-platform equivalent to WIN32 events for signaling between threads and writing your own synchronization primitives, and rsevents-extra a companion crate that provides a few handy synchronization types built on top of the manual- and auto-reset events from the rsevents crate. Aside from the usual awesome helpings of performance improvements, ergonomics enhancements, and more, this latest version of rsevents-extra includes a Semaphore synchronization primitive – something that the rust standard library surprisingly lacks… but not without good reason.","url":"https://neosmart.net/blog/2022/implementing-truly-safe-semaphores-in-rust/","date_published":"2022-10-04T22:41:38Z","author":{"name":"Mahmoud Al-Qudsi"},"tags":["Language"]},{"id":"49019bdc-f00a-4ab0-8653-755100b772be","title":"How (and why) nextest uses tokio, part 1","content_text":"Nextest is faster than cargo test for most Rust projects, and provides a number of extra features, such as test retries, reusing builds, and partitioning (sharding) test runs. To power these features, nextest uses Tokio, the leading Rust async runtime for writing network applications.","url":"https://sunshowers.io/posts/nextest-and-tokio-1/","date_published":"2022-10-04T03:54:56Z","author":{"name":"Rain"},"tags":["Tools and Applications"]},{"id":"aafd6ec2-cf28-410f-8b83-ea6768649a9d","title":"Rewriting the Modern Web in Rust","content_text":"> Building a modern web app with Rust, Bazel, Yew and Axum.\r\n\r\nEarlier this year I rewrote my website with Next.js, React, tsx, and mdx. Having tried full-stack rust in the past, I didn’t think its developer experience was on par with the Next.js stack. Well times have changed, and I wanted to see just how far I could push rust to feel like Next.js. So I did what any developer would do and rewrote my personal site… again.","url":"https://implfuture.dev/blog/rewriting-the-modern-web-in-rust","date_published":"2022-10-04T03:40:49Z","author":{"name":"Kevin King"},"tags":["Web and Network Services"]},{"id":"49e264d1-079b-47c2-8a10-f15441886569","title":"Announcing ICU4X 1.0","content_text":"Hello! Ndeewo! Molweni! Салам! Across the world, people are coming online with smartphones, smart watches, and other small, low-resource devices. The technology industry needs an internationalization solution for these environments that scales to dozens of programming languages and thousands of human languages.\r\n\r\nEnter ICU4X. As the name suggests, ICU4X is an offshoot of the industry-standard i18n library published by the Unicode Consortium, ICU (International Components for Unicode), which is embedded in every major device and operating system.","url":"https://blog.unicode.org/2022/09/announcing-icu4x-10.html","date_published":"2022-09-29T23:20:12Z","author":{"name":"Unicode, Inc."},"tags":["Crates"]},{"id":"2ab5a531-a2ca-40a8-a60e-b04ec814a22d","title":"Announcing the Rust Style Team","content_text":"The standard Rust style resulted from development and discussion within the Rust style team, between 2016 and 2018. After publishing the style guide, the Rust style team concluded its active work, by design.\r\n\r\nHowever, as the Rust language develops, we have a regular need for improvements to the style guide, such as to support new language constructs. To solve both of these problems, [RFC 3309](https://rust-lang.github.io/rfcs/3309-style-team.html) has revived the Rust style team, with three goals:\r\n\r\n* Making determinations about styling for new Rust constructs\r\n* Evolving the existing Rust style\r\n* Defining mechanisms to evolve the Rust style while taking backwards compatibility into account","url":"https://blog.rust-lang.org/inside-rust/2022/09/29/announcing-the-rust-style-team.html","date_published":"2022-09-29T23:19:13Z","author":{"name":"Josh Triplett"},"tags":["Tools and Applications"]},{"id":"23d19424-6b61-4b68-baf2-86d2bb0339ce","title":"cargo careful: run your Rust code with extra careful debug checking","content_text":"Did you know that the standard library is full of useful checks that users never get to see? There are plenty of debug assertions in the standard library that will do things like check that char::from_u32_unchecked is called on a valid char, that CStr::from_bytes_with_nul_unchecked does not have internal nul bytes, or that pointer functions such as copy or copy_nonoverlapping are called on suitably aligned non-null (and non-overlapping) pointers. However, the regular standard library that is distributed by rustup is compiled without debug assertions, so there is no easy way for users to benefit from all this extra checking.","url":"https://www.ralfj.de/blog/2022/09/26/cargo-careful.html","date_published":"2022-09-29T07:20:47Z","author":{"name":"Ralf Jung"},"tags":["Language"]},{"id":"4c86f33e-b0cb-4dfa-b6b3-f3c9a1afcb57","title":"Futures Concurrency IV: Join Ergonomics","content_text":"In this post I want to show some of the ergonomics improvements IntoFuture might enable, inspired by Swift's recent improvements in async/await ergonomics.","url":"https://blog.yoshuawuyts.com/futures-concurrency-4/","date_published":"2022-09-29T07:12:59Z","author":{"name":"Yoshua Wuyts"},"tags":["Language"]},{"id":"b26fc729-36c3-41ec-818e-f6267d42a630","title":"The perils of pinning","content_text":"Parts of the Rust language may look familiar to C programmers, but the two languages differ in fundamental ways. One difference that turns out to be problematic for kernel programming is the stability of data in memory — or the lack thereof. A challenging session at the 2022 Kangrejos conference wrestled with ways to deal with objects that should not be moved behind the programmer's back.","url":"https://lwn.net/Articles/907876/","date_published":"2022-09-29T03:58:19Z","author":{"name":"Kangrejos"},"tags":["Operating Systems"]},{"id":"7e32d2a6-03bd-4471-8b2d-255412407206","title":"A pair of Rust kernel modules","content_text":"The idea of being able to write kernel code in the Rust language has a certain appeal, but it is hard to judge how well that would actually work in the absence of examples to look at. Those examples, especially for modules beyond the \"hello world\" level of complexity, have been somewhat scarce, but that is beginning to change. At the 2022 Kangrejos gathering in Oviedo, Spain, two developers presented the modules they have developed and some lessons that have been learned from this exercise.","url":"https://lwn.net/Articles/907685/","date_published":"2022-09-23T00:52:42Z","author":{"name":"Jonathan Corbet"},"tags":["Operating Systems"]},{"id":"9bc9aa5b-b07c-47f1-93a0-8c0096c061f3","title":"Compiling Rust with GCC: an update","content_text":"While the Rust language has appeal for kernel development, many developers are concerned by the fact that there is only one compiler available; there are many reasons why a second implementation would be desirable. At the 2022 Kangrejos gathering, three developers described projects to build Rust programs with GCC in two different ways. A fully featured, GCC-based Rust implementation is still going to take some time, but rapid progress is being made.","url":"https://lwn.net/Articles/907405/","date_published":"2022-09-23T00:52:07Z","author":{"name":"Jonathan Corbet"},"tags":["Operating Systems"]},{"id":"7b0c67b7-6646-4800-9b33-16dc40bbf7ac","title":"Rust for the Polyglot Programmer","content_text":"There are many guides and introductions to Rust.\r\n\r\nThis one is something different: it is intended for the experienced programmer who already knows many other programming languages.\r\n\r\nI try to be comprehensive enough to be a starting point for any area of Rust, but to avoid going into too much detail except where things are not as you might expect.","url":"https://www.chiark.greenend.org.uk/~ianmdlvl/rust-polyglot/intro.html","date_published":"2021-09-30T23:08:52Z","author":{"name":"Ian Jackson"},"tags":["Getting Started"]},{"id":"5137e1b7-3344-4ab4-a23e-cda409e7e0f4","title":"Adding Rust-Stable libstd Support for Xous","content_text":"Embedded targets lack Rust’s libstd, which in turn means they lack the conveniences of structures such as Vec, HashMap, Mutex, and Box. I added support for my OS, Xous, to the Rust compiler’s stable channel without rebuilding the entire Rust ecosystem, thus enabling libstd support for an entirely new operating system. In this post I’ll show how it’s done. \r\n \r\ntl;dr: It is possible to add support for a new OS to the Rust compiler’s stable channel without rebuilding everything, enabling libstd support for entirely new operating systems.","url":"https://www.crowdsupply.com/sutajio-kosagi/precursor/updates/adding-rust-stable-libstd-support-for-xous","date_published":"2021-08-04T23:44:56Z","author":{"name":"Sean C"},"tags":["Embedded"]},{"id":"85880050-b10b-4dff-8e8d-9ebe0ba9dac1","title":"Improvements for #[doc] attributes in Rust","content_text":"Since Rust 1.54, we can now use function-like macros in attributes. It has a lot of advantages for the #[doc] attribute, let's check some of them!","url":"https://blog.guillaume-gomez.fr/articles/2021-08-03+Improvements+for+%23%5Bdoc%5D+attributes+in+Rust","date_published":"2021-08-03T22:32:48Z","author":{"name":"Guillaume Gomez"},"tags":["Language"]},{"id":"441fe215-d96a-46f9-9b14-d8454e96bf5c","title":"The push for GATs stabilization","content_text":"So, what does that mean? Well, all it really means is that when you use this feature on nightly, you'll no longer get the \"generic_associated_types is incomplete\" warning. However, the real reason this is a big deal: we want to stabilize this feature. But we need your help. We need you to test this feature, to file issues for any bugs you find or for potential diagnostic improvements. Also, we'd love for you to just tell us about some interesting patterns that GATs enable over on Zulip!","url":"https://blog.rust-lang.org/2021/08/03/GATs-stabilization-push.html","date_published":"2021-08-03T22:21:59Z","author":{"name":"Jack Huey"},"tags":["Language"]},{"id":"f6cc142b-0e71-4f14-961b-04acaed22f18","title":"Rust 2021 public testing period","content_text":"We are happy to announce that the Rust 2021 edition is entering its public testing period. All of the planned features for the edition are now available on nightly builds along with migrations that should move your code from Rust 2018 to Rust 2021. If you'd like to learn more about the changes that are part of Rust 2021, check out the nightly version of the Edition Guide.","url":"https://blog.rust-lang.org/2021/07/21/Rust-2021-public-testing.html","date_published":"2021-07-21T22:07:50Z","author":{"name":"Niko Matsakis"},"tags":["Language"]},{"id":"84c45d47-0af7-4dbd-b255-11e32ef734d4","title":"Rust in the Android platform","content_text":"In addition to ongoing and upcoming efforts to improve detection of memory bugs, we are ramping up efforts to prevent them in the first place. Memory-safe languages are the most cost-effective means for preventing memory bugs. In addition to memory-safe languages like Kotlin and Java, we’re excited to announce that the Android Open Source Project (AOSP) now supports the Rust programming language for developing the OS itself. ","url":"https://security.googleblog.com/2021/04/rust-in-android-platform.html","date_published":"2021-04-06T22:48:04Z","author":{"name":"Jeff Vander Stoep and Stephen Hines"},"tags":["Operating Systems"]},{"id":"4dbb6701-62e7-4f07-a1fb-e615e7209edd","title":"Building a shared vision for Async Rust","content_text":"The Async Foundations Working Group believes Rust can become one of the most popular choices for building distributed systems, ranging from embedded devices to foundational cloud services. Whatever they're using it for, we want all developers to love using Async Rust. For that to happen, we need to move Async Rust beyond the \"MVP\" state it's in today and make it accessible to everyone.\r\n\r\nWe are launching a collaborative effort to build a shared vision document for Async Rust. Our goal is to engage the entire community in a collective act of the imagination: how can we make the end-to-end experience of using Async I/O not only a pragmatic choice, but a joyful one?","url":"https://blog.rust-lang.org/2021/03/18/async-vision-doc.html","date_published":"2021-03-18T22:42:10Z","author":{"name":"Niko Matsakis"},"tags":["Language"]},{"id":"5f441546-be0e-4188-8da7-ca50dd09a055","title":"Ferrocene Part 3: The Road","content_text":"Ferrocene is an effort led by Ferrous Systems and its newly formed subsidiary Critical Section GmbH to qualify the Rust Language and Compiler for use in the safety-critical domain. This is the third post in a series detailing our plans and actions around this effort, addressing topics discussed in The Pitch and The Plan. Ferrocene's draft name was \"Sealed Rust.\"","url":"https://ferrous-systems.com/blog/ferrocene-update-three-the-road/","date_published":"2021-02-25T00:43:54Z","author":{"name":"Ferrous Systems"},"tags":["Language"]},{"id":"a0ccf1a1-71f4-4af0-b747-4edfaf9e8852","title":"Rust & the case of the disappearing stack frames","content_text":"The requirements of our current charter, and the RFC creating the group, are effectively fulfilled by the specification of \"C unwind\", so one option is to simply wind down the project group. While drafting the \"C unwind\" RFC, however, we discovered that the existing guarantees around longjmp and similar functions could be improved. Although this is not strictly related to unwinding1, they are closesly related: they are both \"non-local\" control-flow mechanisms that prevent functions from returning normally. Because one of the goals of the Rust project is for Rust to interoperate with existing C-like languages, and these control-flow mechanisms are widely used in practice, we believe that Rust must have some level of support for them.","url":"https://blog.rust-lang.org/inside-rust/2021/01/26/ffi-unwind-longjmp.html","date_published":"2021-01-28T03:46:29Z","author":{"name":"Kyle Strand on behalf of the FFI-unwind project group"},"tags":["Language"]},{"id":"2869a0d6-d630-4596-b50d-48553d2812e0","title":"Rust in Production: 1Password","content_text":"To learn why this language is favored so much between developers, we have started a new series on Rust in production. In it, we’ll interview people that have used Rust for significant projects: apps, services, startup MVPs, and others.\r\n\r\nFor the first installment of the series, we interview Michael Fey, VP of Engineering at 1Password. Read further to find out why they chose Rust for their product, the benefits of Rust for security-centered applications, and what cool libraries you should look into if you’re developing something similar in Rust.","url":"https://serokell.io/blog/rust-in-production-1password","date_published":"2021-01-21T07:07:23Z","author":{"name":"Gints Dreimanis"},"tags":["Language"]},{"id":"71899e08-d8b2-439c-8f13-28f00a37eecf","title":"Rustdoc performance improvements","content_text":"Hi everyone! @GuillaumeGomez recently tweeted about the rustdoc performance improvements and suggested that we write a blog post about it: \r\n \r\n> The performance comparison between @rustlang rustdoc now and rustdoc 4 months ago are crazy! The rustdoc cleanup going on (we're still far from done!) is having a huge positive impact! Can't wait to see how much better the results will be.  Maybe I should write a blog post? pic.twitter.com/XapdmdZ1IZ — Guillaume Gomez (@imperioworld_) January 13, 2021\r\n   \r\nThe tweet received a lot of comments approving the blog post idea so here we go!","url":"https://blog.rust-lang.org/inside-rust/2021/01/15/rustdoc-performance-improvements.html","date_published":"2021-01-21T07:03:57Z","author":{"name":"Joshua Nelson and Guillaume Gomez"},"tags":["Performance"]},{"id":"320973eb-c4e7-419a-8443-384639d658d6","title":"Announcing Rust 1.49.0","content_text":"The Rust team is happy to announce a new version of Rust, 1.49.0. For this release, we have some new targets and an improvement to the test framework.","url":"https://blog.rust-lang.org/2020/12/31/Rust-1.49.0.html","date_published":"2021-01-01T22:33:12Z","author":{"name":"The Rust Release Team"},"tags":["Language"]},{"id":"314e60e2-4220-45fa-a597-7f743e94577e","title":"Sequoia PGP v1.0 Released: The Seedling's a Sapling","content_text":"Version 1.0. It’s here. After three and a half years of development, we are happy to announce the release of version 1.0 of Sequoia!\r\n\r\nThe release includes the low-level crate sequoia-openpgp, and a program to verify detached signatures geared towards software distribution systems called sqv.","url":"https://sequoia-pgp.org/blog/2020/12/16/202012-1.0/","date_published":"2020-12-16T22:04:35Z","author":{"name":"Neal"},"tags":["Tools and Applications","Security"]},{"id":"44604af1-3b26-4526-8469-3fc3b32dade0","title":"Launching the Lock Poisoning Survey","content_text":"The Libs team is looking at how we can improve the std::sync module, by potentially splitting it up into new modules and making some changes to APIs along the way.\r\nOne of those API changes we're looking at is non-poisoning implementations of Mutex and RwLock.\r\n\r\nTo find the best path forward we're conducting a survey to get a clearer picture of how the standard locks are used out in the wild.","url":"https://blog.rust-lang.org/2020/12/11/lock-poisoning-survey.html","date_published":"2020-12-14T22:26:49Z","author":{"name":"Ashley Mannix"},"tags":["Language"]},{"id":"f5a55edd-f3b5-459d-bef9-41239a2997cd","title":"Announcing Minus, a cross-platform pager","content_text":"In this blog post, I want to talk about Minus, which is a cross-platform, asynchronous terminal paging library written in Rust.","url":"http://pijul.org/posts/2020-12-09-minus/","date_published":"2020-12-09T22:42:13Z","author":{"name":"Arijit Dey"},"tags":["Crates"]},{"id":"5e4230e0-1879-4314-a2d1-da33d4388b13","title":"lib-ruby-parser: A Ruby Parser Written in Rust","content_text":"So, I’m ready to announce that I’ve finished working on a new Ruby parser. It’s called lib-ruby-parser. Key features:\r\n\r\n1. It’s fast.\r\n2. It has a beautiful interface.\r\n3. It’s precise.\r\n4. It doesn’t depend on Ruby.","url":"https://ilyabylich.svbtle.com/lib-ruby-parser","date_published":"2020-11-27T22:13:25Z","author":{"name":"Ilya Bylich"},"tags":["Crates"]},{"id":"3b12df03-9627-4c4c-8c91-d56079e52f5a","title":"Announcing Rustup 1.23.0","content_text":"Rustup is now natively available for the new Apple M1 devices, allowing you to install it on the new Macs the same way you'd install it on other platforms!\r\n\r\nStarting from this release of rustup (1.23.0) you can also install a minor version without specifying the patch version, like 1.48 or 1.45.","url":"https://blog.rust-lang.org/2020/11/27/Rustup-1.23.0.html","date_published":"2020-11-27T22:10:09Z","author":{"name":"The Rustup Working Group"},"tags":["Language"]},{"id":"127e2f60-d549-450e-bd04-c711aea4ecf3","title":"What the Error Handling Project Group is Working On","content_text":"The Rust community takes its error handling seriously. There’s already a strong culture in place for emphasizing helpful error handling and reporting, with multiple libraries each offering their own take (see Jane Lusby’s thorough survey of Rust error handling/reporting libraries).\r\n\r\nBut there’s still room for improvement. The main focus of the group is carrying on error handling-related work that was in progress before the group's formation. To that end, we're working on systematically addressing error handling-related issues, as well as eliminating blockers that are holding up stalled RFCs.","url":"https://blog.rust-lang.org/inside-rust/2020/11/23/What-the-error-handling-project-group-is-working-on.html","date_published":"2020-11-24T06:24:26Z","author":{"name":"Sean Chen"},"tags":["Language"]},{"id":"f2dd94db-ddf5-4c16-aa0c-2890b856c586","title":"Announcing Rust 1.48.0","content_text":"The Rust team is happy to announce a new version of Rust, 1.48.0. The star of this release is Rustdoc, with a few changes to make writing\r\ndocumentation even easier!","url":"https://blog.rust-lang.org/2020/11/19/Rust-1.48.html","date_published":"2020-11-19T20:12:19Z","author":{"name":"The Rust Release Team"},"tags":["Language"]},{"id":"8d5a5ec1-0141-4745-8e5f-b4a6253e471f","title":"Exploring PGO for the Rust compiler","content_text":"For the last few months Mozilla has been using Profile-Guided Optimization (PGO) to build their own optimized version of Clang, leading to an up to 9% reduction of Firefox compile times on their build infrastructure. Would the same be possible for the Rust compiler, that is, could we apply profile-guided optimization to rustc itself in order to make it faster? This post explores exactly this question, detailing first the steps needed for generating a PGOed versions of rustc (in two flavors), and then taking a look at the resulting performance implications. But before that let's have a little reminder what PGO even is and how it works in general.","url":"https://blog.rust-lang.org/inside-rust/2020/11/11/exploring-pgo-for-the-rust-compiler.html","date_published":"2020-11-11T22:03:44Z","author":{"name":"Michael Woerister"},"tags":["Performance"]},{"id":"c8b1a205-d11b-4028-b283-fe1dbcbd495b","title":"Introducing Scipio - a Thread-per-Core Crate for Rust & Linux","content_text":"This article will explore the thread-per-core model with its advantages and challenges, and introduce Scipio (you can also find it on crates.io), our solution to this problem. Scipio allows Rust developers to write thread-per-core applications in an easy and manageable way.","url":"https://www.datadoghq.com/blog/engineering/introducing-scipio/","date_published":"2020-11-04T23:52:51Z","author":{"name":"Glauber Costa"},"tags":["Crates","Performance"]},{"id":"e0e60133-6e7b-46a5-9836-fe482295f6f5","title":"Non-Generic Inner Functions","content_text":"Steve Klabnik recently wrote about whether out parameters are idiomatic in Rust. The post ends by showing a snippet of code: a generic function, with a non-generic function inside of it which contains the actual implementation. Steve says this pattern may warrant its own post, so here is that post, where I’ll explain why this inner function is useful, discuss the trade-offs of doing it, and describe why this pattern will hopefully not be necessary in the future.","url":"https://www.possiblerust.com/pattern/non-generic-inner-functions","date_published":"2020-10-21T22:48:08Z","author":{"name":"Andrew Lilley Brinker"},"tags":["Language"]},{"id":"71ce0cf6-05fc-4aca-9485-85ed2b8be1bc","title":"Rust after the honeymoon","content_text":"Two years ago, I had a blog entry describing falling in love with Rust. Of course, a relationship with a technology is like any other relationship: as novelty and infatuation wears off, it can get on a longer term (and often more realistic and subdued) footing — or it can begin to fray. So well one might ask: how is Rust after the honeymoon?","url":"http://dtrace.org/blogs/bmc/2020/10/11/rust-after-the-honeymoon/","date_published":"2020-10-12T09:55:52Z","author":{"name":"Bryan Cantrill"},"tags":["Language"]},{"id":"2dc32b74-bd93-41d6-812e-d20001d05966","title":"Rust in curl with Hyper","content_text":"tldr: work has started to make Hyper work as a backend in curl for HTTP.","url":"https://daniel.haxx.se/blog/2020/10/09/rust-in-curl-with-hyper/","date_published":"2020-10-09T22:07:08Z","author":{"name":"Daniel Stenberg"},"tags":["Web and Network Services"]},{"id":"2954ca43-e797-43fb-b590-33933c969fbe","title":"Announcing Rust 1.47.0","content_text":"This release contains no new language features, though it does add one long-awaited standard library feature. It is mostly quality of life improvements, library stabilizations and const-ifications, and toolchain improvements. See the detailed release notes to learn about other changes not covered by this post.","url":"https://blog.rust-lang.org/2020/10/08/Rust-1.47.html","date_published":"2020-10-08T22:14:49Z","author":{"name":"The Rust Release Team"},"tags":["Language"]},{"id":"0ca9336a-4fde-4983-8670-a09221b0865b","title":"Rust + Raspberry Pi Tide Clock","content_text":"In this part 1 of 2 posts, I share the process of a heartwarming maker project built on top of Raspberry Pi and Rust. It's more a story than a how-to guide, but provides an interesting chronology of problems encountered. In part 2 I'll be getting technical and discussing Rust in-depth.","url":"https://thefuntastic.com/blog/rust-tide-clock","date_published":"2020-10-07T22:23:34Z","author":{"name":"Peter Cardwell-Gardner"},"tags":["Embedded"]},{"id":"f74d7084-d61f-460d-be70-54947c2284c6","title":"Announcing the Portable SIMD Project Group","content_text":"We're announcing the start of the Portable SIMD Project Group within the Libs team. This group is dedicated to making a portable SIMD API available to stable Rust users.","url":"https://blog.rust-lang.org/inside-rust/2020/09/29/Portable-SIMD-PG.html","date_published":"2020-09-30T06:24:34Z","author":{"name":"Jubilee and Lokathor"},"tags":["Language","Operating Systems"]},{"id":"341c352a-c261-497a-86f5-c957508f498e","title":"Porting EBU R128 audio loudness analysis from C to Rust","content_text":"Over the last few weeks I ported the libebur128 C library to Rust, both with a proper Rust API as well as a 100% compatible C API.","url":"https://coaxion.net/blog/2020/09/porting-ebu-r128-audio-loudness-analysis-from-c-to-rust/","date_published":"2020-09-22T22:32:03Z","author":{"name":"Sebastian Dröge"},"tags":["Crates"]},{"id":"d236ea20-477c-4eaa-9549-e8ba5d50ad06","title":"Async Iteration Semantics","content_text":"In a recent lang team meeting we discussed the upcoming Stream RFC. We covered both the steps required to land it, and the steps we'd want to take after that. One of the things we'd want eventually for streams is: \"async iteration syntax\". Just like for x in y works for Iterator, we'd want something similar to work for Stream.","url":"https://blog.yoshuawuyts.com/async-iteration/","date_published":"2020-09-22T22:00:16Z","author":{"name":"Yoshua Wuyts"},"tags":["Language"]},{"id":"ef655d7e-05b9-4f26-8168-0709c6729676","title":"Rust 2021 – Ethical Development","content_text":"This is my Rust 2021 post. I believe that Rust has shown that “bending the curve” is\r\nboth possible and fruitful in programming language design. We also have a strong set\r\nof values as a community, enshrined both in the Code of Conduct and the example of\r\nvarious high-profile rustaceans.\r\n\r\nFor 2021 I really couldn’t care less what features go into the next edition. Don’t\r\nget me wrong, I want the next edition to be awesome, but I believe this is table\r\nstakes by now. I want us to take on the harder problems.","url":"https://llogiq.github.io/2020/09/21/ethics.html","date_published":"2020-09-21T22:00:21Z","author":{"name":"Llogiq"},"tags":["Rust 2021"]},{"id":"d88da501-4e4e-4b6c-b064-62e69e6b0aa4","title":"Call for 2021 Roadmap Blogs Ending Soon","content_text":"We will be closing the collection of blog posts on October 5th. As a reminder, we plan to close the survey on September 24th, later this week.","url":"https://blog.rust-lang.org/2020/09/21/Scheduling-2021-Roadmap.html","date_published":"2020-09-21T21:40:21Z","author":{"name":"The Rust Core Team"},"tags":["Language"]},{"id":"24c81c1c-4c09-4375-9282-11986c5ecc1a","title":"Low-Level Academy","content_text":"I'm excited to launch Low-Level Academy, an explorable systems programming course that uses Rust and web assembly for interactive playgrounds and visualisation. It starts with network programming, but it will be expanded to more topics!","url":"https://lowlvl.org/","date_published":"2020-09-21T00:40:23Z","author":{"name":"Nikita Baksalyar"},"tags":["Getting Started"]},{"id":"07d182e9-6e49-491a-b6ca-6d70bc9ac22a","title":"Throw Away Code","content_text":"There’s an ongoing discussion about what makes Python better prototyping language than Rust (with Python being probably just the archetype of some scripted weakly-typed language). The thing is, I prefer doing my prototypes in Rust over Python. Apparently, I’m not the only one. So I wanted to share few things about what makes Rust viable for these kinds of throw-away coding sprints, at least for me.\r\n","url":"https://vorner.github.io/2020/09/20/throw-away-code.html","date_published":"2020-09-21T00:29:34Z","author":{"name":"Michal Vaner"},"tags":["Language"]},{"id":"752c8ca7-d8d2-490a-aabb-536b9215c42e","title":"TL;DR Rust","content_text":"Recently I've been starting to use Rust more and more for larger and larger projects. As things have come up, I realized that I am missing a good reference for common things in Rust as compared to Go. This post contains a quick high-level overview of patterns in Rust and how they compare to patterns in Go. This will focus on code samples. This is no replacement for the Rust book, but should help you get spun up on the various patterns used in Rust code.","url":"https://christine.website/blog/TLDR-rust-2020-09-19","date_published":"2020-09-19T22:26:04Z","author":{"name":"Christine Dodrill"},"tags":["Getting Started"]},{"id":"2a142e61-0efc-4773-a67e-c9a489461967","title":"Rust 2021: Make it accessible","content_text":"More than any one thing, at it’s core Rust provides a lot of value to it’s users. Programs written in Rust are free of entire classes of bugs thanks to rustc having your back. The core idea of borrowing and lifetimes providing memory safety without a GC is so powerful that it will eventually become mainstream. After a point, all new programs will be written in a language that is memory safe, whether that safety is provided by a GC, or by Rust, or a language that copies Rust’s features. It may take 10, 20 or 50 years, but we will get there. As an end user, that makes me happy.\r\n\r\nSince the success of Rust or a Rust clone/copycat is guaranteed on a long enough timescale, the question becomes - how can we accelerate that?","url":"https://blog.nindalf.com/posts/rust-2021/","date_published":"2020-09-19T22:14:54Z","author":{"name":"Krishna Sundarram"},"tags":["Rust 2021"]},{"id":"3b4de905-668e-478b-b70f-ad55ed2c54aa","title":"Introducing auditable: audit Rust binaries for known bugs or vulnerabilities in production","content_text":"Today I'm pleased to announce the initial release of auditable crate. It embeds the dependency tree into the compiled executable so you can check which crates exactly were used in the build. The primary motivation is to make it possible to answer the question \"Do the Rust binaries we're actually running in production have any known vulnerabilities?\" - and even enable third parties such as cloud providers to automatically do that for you.","url":"https://www.reddit.com/r/rust/comments/iotx5u/introducing_auditable_audit_rust_binaries_for/","date_published":"2020-09-14T11:07:44Z","author":{"name":"Sergey \"Shnatsel\" Davidoff"},"tags":["Security"]}]}