Ecological landscape year-end inventory Rust | the ocean (last)

Author | Zhang Handong

This article is part of the “2021 Technology Review” series, which focuses on the important progress of Rust ecological map in 2021.

“2021 Year-end Technical Inventory” is a major project launched by Digger, covering Serverless, Service Mesh, big front end, database, artificial intelligence, low code, edge computing and many other technical fields. Looking to the past, to the future, review the development of IT technology in 2021, inventory the major events of IT technology, and forecast the future trend of IT technology. In the meantime, we’re kicking off our 15th tech-themed essay, with a look at what you see as the tech trends of 2022.

The text before

Half a year ago, I wrote “30,000 Words | Rust Industry Research Report 2021”, which consists of an introduction to the Rust language and an inventory of open source applications in the industry. Half a year later, I feel it is necessary to write another year-end Rust ecological survey report. This is because I want to provide you with a comprehensive perspective. By mining various scattered and hidden information on the Internet, I will eventually draw an “ecological map” of Rust so that you can understand the Rust language as objectively and fairly as possible.

After finishing this report, I came to the conclusion that Rust is not meant to be used to rewrite everything, but to be used to create a new future. Of course, this is only my personal opinion and does not represent anyone or any organization or company. If you have a different point of view, welcome to discuss.

We choose to use Rust, not because it is easy, but because it is hard, because that goal will serve to organize and measure the best of our energies and skills, because that challenge is one that we are willing to accept, one we are unwilling to postpone, and one which we intend to win, and the others, too.

We choose Rust not because it is easy, but because it is difficult. This helps us to organize and measure how much energy and skill we can put into an optimal goal. When we accept a challenge, it means that the challenge is one we are willing to accept, willing to jump in right away, and must win. So should other challenges.

All contents of this report are from public information on the Internet. If there are any errors or contents that are not suitable for this report, please inform us immediately.

The outline

This report contains the following contents:

Status of the Rust Project
Status and trends of Rust applications in various fields
Rust job distribution
The prevalence of Rust in education

Status of the Rust Project

By the end of 2021, it has been six and a half years since Rust was officially released on May 15, 2015. During those six and a half years, Rust released a large version, called Edition, every three years.

This translation comes from the term book publishing. Examples include the first and second editions of Rust The Tao of Programming.

The meaning of Edition

Editions were introduced primarily so that Rust could easily introduce backward-incompatible features as it evolved without affecting previous code. For example, Rust 2018 Edition does not have the async/await keyword, but the 2021 Editon introduces the async/await keyword to avoid breaking the old code let async = 1; I’ll write it like this. Edition and semantic edition are orthogonal concepts.

Each edition published by Rust has its core theme meaning:

2015 Edition: The theme is “Stability”. The 2015 Edition represents a leveling off of Rust 1.0. Rust changed daily prior to 1.0, and after 1.0 meant that teams worked on backward compatibility so that developers could steadily build projects with Rust. The concept of editions was only introduced in 2017, so any semantic version numbers prior to the official 2015 release, i.e., 1.0, are classified as 2015 Edition.
2018 Edition: The theme is “Productivity”. Much of what was introduced in the 2018 Edition was backward compatible, meaning that some of the features, such as the improved NLL for borrowing checks, could be used in 2015. However, improvements to the module system are only available in the 2018 Edition. Since 2018 EIDtion is themed around productivity, feature priorities will take precedence over that theme.
2021 Edition: The theme is “Mature”. Instead of introducing many new features, the 2021 Edition clears up some technical debt, such as ongoing refactorings and improvements to the Rust compiler, including the new trait systems Chalk and Query used internally (open source: Github.com/nikomatsaki… Constant generics, generic associated types, and so on.

Rust Edition is now established and will be released every three years. This means that every three years Rust revolves around a theme that leads Rust’s growth.

2024 Edition outlook

2024 Edition: The theme may be “widely used”.

On February 9, 2021, the Rust Foundation was announced. Leading technology companies such as Huawei, AWS, Google, Microsoft, Mozilla and Facebook have joined the Rust Foundation as platinum members to promote and develop the Rust language around the world.

Since then, ambitious companies from ARM, AUTOMATA, 1PASSword, Toyota, Activision, Knoldus, Tangram and many others have joined the foundation to help promote Rust.

The Rust Foundation recently elected Rebecca, who has 15 years of experience in nonprofit organizations, as its Executive Director (ED) and CEO. It is believed that under the leadership of Rust Foundation, Rust will have broad application prospects.

Opportunities and Challenges of Rust Project

The Rust language is completely open source, and it is the largest open source community organization in the world. Teams and workgroups with different responsibilities work together. Details can be found on Rust’s official website. It currently has 3,539 contributors.

To date, crates has been downloaded 11,012,362,794 times, or 11 billion times.

We can use these metrics to gauge Rust’s maturity.

The number of users: Rust has been the most popular language among users for six consecutive years, but the actual number of users can be seen fromTIOBEAs of November 2021, Rust ranks 29th in popularity0.54%. Any failure to enterTIOBEAll of the top 20 languages still need to be marketed and publicized, which means Rust remains a niche language.
Number of contributors. The number of Rust contributors to date is3539A. Let’s compare thatGithubOpen source other languages: popularGoLanguage current contributors are1758A;KotlinThe current contributors are516A. Take a look at the popular framesRailsThe contributors are4379A. The number of contributors to the Rust language is relatively large.
Bug fix/patch frequency. According to theGithub issuesFor data, Rust currently fixes an average of one issue per hour visible to the naked eye. Since the first submission by Rust founder Graydon on June 17, 2010, the total has been fixed33942 个issues 和 49011 个 PRTen years3832Day calculation, average day repair8An issue,13 个 PR.
Number of unresolved problems. There are currently7515If the average frequency of problem repair is calculated, it is estimated that the problem can be repaired in about 3 years. Three years later, another Edition was released:2024 Edtion.
Repository statistics: The current star number is60500A,watchSeveral have15000A.
StackOverflowQuestion number: Rust related problems are common24924Five, on average, per week150About one question a day20About a question. Compared to other languages,javascriptThe problem2299100A,JavaThe problem1811376A,GoThe problem57536A,CThe problem368957A,CppThe problem745313A. Compared to theGoRust has almost half that number of problems.
Frequency of new feature releases: Rust releases a new version every six weeks.
Stable: Rust is already stable.
API Change the frequency: stable versionAPIBasically not going to change.
Whether there are “core” developers: Rust core developers are numerous and are organized and assigned by working groups, as per Rust Team Governance
Document quantity and quality:APIDocuments, books, tutorials, and blogs. RustAPIThe documents are quite mature and advanced. At present, there are more and more Rust books at home and abroad. Rust Weekly publishes many rust-related blogs, videos and other articles in the community every week.
Community response frequency: How experienced users can help new users. Rust communities are available at home and abroad to help community members communicate through group organizations, forums, offline activities and more.
Business supportThe Rust Foundation has been established: Google, Huawei, Microsoft, Amazon,Facebook, Mozilla, Toyota, Activision, and others are on its board.
Number of well-known projects and product applications: open sourceCNCFSome well-known projects: Database (TiKV), cloud native (Linkerd.Krustlet), event flow system (Tremor), andGoogle Andriod, Amazon, Microsoft and others all support Rust development and blockchain (Near, Solana, Parity, etc.). Chinese companies using Rust: Ant Financial, PingCAP, Bytedance, Miape, Xita, Haizhi Star Map, Non-convex Technology, etc. There are many excellent projects or products that are not listed here.
The number of “terror incidents”, if not this, is evidence that it is not being used in a realistically challenging production environment. Rust has a dedicated information security working group and a dedicated website to document “terror incidents” related to Rust ecology: rustsec.org/.
Toolchain support: new linker support (MOLD)/new Trace Tool (Tracy)/Profiler commercial products also support Rust (Superluminal) and more.

Using the analogy of a plant’s growth stage (” seeding, germinating, flowering, fruiting “), Rust’s maturity would be in the “flowering” stage.

As a new language, Rust language is popular at present, but it still faces many challenges.

There are two main challenges:

Field selection. A language, however well sung, is of little use if it is not used. The current challenge of the Rust language is its application in the domain. Most notably, Rust’s entry into Linux kernel development, if successful, could be epoch-making.
The evolution of language’s own characteristics. The Rust language still has many features to support and evolve, and here are some that need to be improved.

The choice of domain is discussed in the next section, “The State and Trends of Rust in various domains.” Let’s take a look at what features of the Rust language itself need to evolve to meet the 2024 Edition phase goals.

Initial results of Rust language memory security appear

According to SOK: On the Analysis of Web Browser Security, a paper published On arXiv On December 31, 2021:

Comparing the four browser architectures and the fact that memory security is still the dominant issue in browsers over the last decade. But watch Firefox replace 12% of components through the Oxidation project (Rust). Since 2015, Firefox has seen a small but steady decline in the number of memory security vulnerabilities, including a significant drop in renderers.

Oxidation is a project specifically designed to integrate Rust code into Firefox. Rust support has been required on all platforms since Firefox 54, and the first major Rust component was released in Firefox 56 (EncoDING_RS) and 57 (Stylo). Looking ahead, THE goal of Oxidation is to make using Rust in Firefox easier and more efficient, and to increase the amount of Rust code in Firefox accordingly.

It can be said that after six years of application, Rust language memory security has finally seen the initial results. The paper recommends that browser vendors follow this best practice and gradually move their browsers to memory-safe languages.

Rust language features to be perfected

Rust must address the following issues in order to move forward:

Error handling improvement. inRFC 3058Described in theTryTrait improvements to achieve unity in error handling.
Safety I/O. Recently Rust officials merged one RFC 3128By introducing the concept of I/O security and a new set of types and attributes forAsRawFdUsers of and related attributes provide assurance about their original resource handles, thus closing the encapsulation boundary hole in Rust.
Generic association typesGAT. Generic association types in RFC 1598 Is defined in. This feature is often compared to HaskellHKT(Higher Kinded Type), that is, the higher-order type. Although similar, Rust does not translate Haskell’sHKTAs is, but given for Rust itselfGAT(Generic associated type)The concept of.
Generic Specialization. The concept of generic specialization corresponds to the template specialization of Cpp. However, Cpp support for specialization is quite complete, whereas specialization in Rust is not yet stable. An implementation standard for Rust’s generic specialization is defined in RFC #1210, and its implementation status is tracked in Issue #31844. There are still many unresolved issues.
Async trait && Async Drop. Rust asynchrony is now stable, but there is still a lot to be done. To this end, asynchronous workgroups have been created and an asynchronous infrastructure initiative has been created to facilitate this process. In addition, the official discussion of the standardization of asynchronous runtimes has also been opened, in an effort to achieve portability and interoperability of asynchronous runtimes.
Stabilization of coroutines. At present Rust asynchrony is implemented based on a semi-coroutine mechanism called Generator, but Generator features are not stable. The topic of generator feature stability comes up in the Rust forum from time to time, because generator features are also common and useful features in other languages.
Portable SIMD. The Rust team has released portable-simd, and you can now use this library instead of Packed_simd at Nightly. This library makes it easier and safer to develop cross-platform SIMDs with Rust. In the near future, it will also be introduced into the standard library to stabilize.
The newasm!support.asm!Macros allow inline assembly in Rust. inRFC #2873Is stipulated in the newasm!Macro syntax, which will be compatible with ARM, x86, risC-V architectures, etc., to facilitate the addition of more architecture support in the future. Before theasm!The macro has been renamed tollvm_asm!. The current newasm!It’s close to stable. It’s available inissue #72016In the tracking. Basically, let’sasm!Macros are more versatile than macrosllvm_asm!It has better syntax.
Rustdoc ascension. Rust is an elegant language. And this grace is very complete. In addition to the elegant design of many of the language’s features, another bright spot is Rustdoc. The Rust Official Doc Working Group is committed to making Rustdoc a great tool. Rustdoc is simple to use, creates very beautiful pages, and makes writing documentation a pleasure. For more information about Rustdoc, see the Rustdoc Book.
The list of Rust for Linux unstable features is listed in the wish list. This was done with the Rust for Linux team.
New GCC back end. Rust support for a new GCC back end has long been on the agenda in order to drive Rust for Linux. Among themrustc_codegen_gcc The fastest progress, so far has passed the partialrustcThe test,rustc_codegen_llvm Is currently the main development project,Rust GCC It is expected to be completed in 1-2 years.
Stabilize the allocator API. Add standard allocator interfaces and support for user-defined allocators, allow different collections to support different allocators, and so on. The concrete inRFC 1398A full description is provided in. The current status isVec<T>Added an allocator generic parameter.

The above list is only part of the work Rust needs to do to address the problem; there is much more to be done. The Rust language is still evolving.

Issues highlighted in Rust open source governance

This year, mod Team of the Rust Open Source Organization quit the team, which caused a wide discussion in the technical community at home and abroad.

According to the official description, the conflict arises from a disagreement between the audit team and core team members about how to handle the audit. As these conflicts involve the privacy of many people involved, the authorities cannot reveal more inside information, which leads to a lot of speculation and exaggerated impact on the matter. There was no need for the outside world to know that this was an internal matter within Rust’s official team.

Managing a volunteer open source project larger than most companies is difficult. They have a lot of work to do, but they believe Rust Project will be stronger for it. While these issues are serious enough to warrant cautious positive conclusions, they are confident that they will not negatively impact the Rust language and its ability to improve its core tools, documentation, and support.

For my friends in the Chinese-language community and tech media who care about Rust, I don’t think there’s any need to read too much into it. Because we do not know what the American society and people in the society are concerned about and sensitive issues, it is difficult to really understand because of cultural differences. All we know is that this is a problem that a volunteer open source organization larger than most companies has to deal with, and once solved, the community will evolve and become stronger. So there’s no need to worry about Rust being negatively affected.

But at this point, I was reminded of a quote from the official blog when Rust 1.44 was released in 2020: “Tech is and always will be political.”

At that time, coinciding with the killing of a black man by a white police officer on his knees in Minnesota, all corporate America is now lining up. So Rust had to declare itself a firm opponent of police brutality in America. It seemed normal at the time, but I hadn’t noticed that there had been a lot of discussion about it on the official Intranet, and looking back on it now, it doesn’t feel like it was an accident.

As a stranger to American culture, I used to turn my nose up at the importance of audit team. Now I feel how important audit team is for Rust, a country with complicated culture and politics. I finally understand why Rust’s official team says the background to this story is quite complicated.

I wish the Rust community had less political, racial and other non-technical rhetoric and contradictions. The Rust language is global, not national. I really hope the Rust team can handle this. What can be done about it? Maybe we can only pray for world peace.

Status and trends of Rust applications in various fields

Next, let’s take a look at the state and likely trends of Rust application in various fields in 2021.

The operating system

Start with the operating system.

Rust for Linux

Rust’s entry into Linux has been a topic of conversation since June 2020. Linus, the Linux creator, spoke at the Open Source Summit and the Embedded Linux Conference at the time about finding future maintainers for the open kernel.

“The kernel is boring, or at least most people think it is,” Linus said. A lot of new technology should be more fun for a lot of people. Defenders proved hard to find. There are a lot of people writing code, but it’s hard to find someone who can Review someone else’s code upstream. This comes not just from other maintainers, but from all the people who write the code… It just takes time.

Rust, as an inherently secure language and an alternative to C, has been very helpful in helping build trust among kernel developers. Two-thirds of Linux kernel security vulnerabilities (PDF) come from memory security issues, and there is a general consensus that introducing Rust into Linux will make it more secure.

Speaking at the Open Source Summit this year (2021), Linus said, “I think C is a great language, and for me C is really a way to control hardware at a fairly low level. So when I see C code, I can get pretty close to guessing what the compiler is doing. It’s so close to hardware that you can do anything with it. But C’s subtle type interactions aren’t always logical and can be a pitfall for almost everyone. They’re easy to ignore, and in the kernel, that’s not always a good thing. Rust is the first language I’ve seen that looks like it could actually solve a problem. People have been talking about Rust in the kernel for a long time now, but it’s not done yet, and probably next year we’ll start to see some fearless modules written in Rust for the first time, perhaps integrated into the mainline kernel.”

One of the cornerstones of Linux’s longevity, Linus says, is Fun, and Fun is something he’s always pursued. The fun comes when people discuss the possibility of writing some Linux kernel modules using Rust.

The recent progress of Rust into the Linux kernel was discussed again at the Linux Plumbers conference in September 2021.

Miguel Ojedal, lead developer of Rust for Linux, says Rust should be a first-class citizen if it gets into the kernel. Linus replied that the kernel community would almost certainly experiment with the language.
When Rust goes into the kernel, there are bound to be some maintainers who need to learn the language to review Rust code. Rust is not hard to understand, Linus said, and anyone in the kernel community with the ability to review Patch should know the language well enough to review its code.
Ojedal said that the kernel is still working with some Unstable Rust features, which is not compatible enough to ensure that the Rust compiler will compile properly in the future. However, if Rust enters the Linux kernel, this will change. For some Unstable Rust features, the Official Rust team will consider stabilizing them. This is a driving force, and sooner or later a kernel that only uses the Rust stable version will be built, and the compatibility issues will go away.
Another kernel developer, Thomas Gleixner, worries that memory ordering is not officially supported in Rust, which could be problematic. But Paul McKenney, another Linux kernel maintainer who has been concurrently programming CPP for 30 years, has written a series of articles on how the Rust community can properly handle the memory ordering model for Rust entering the Linux kernel. I also wrote another article about this [I read] what memory model should Rust use? .
About Rust’s support for GCC, whichrustc_codegen_gcc The fastest progress, so far has passed the partialrustcThe test,rustc_codegen_llvm Is currently the main development project,Rust GCC It is expected to be completed in 1-2 years.

The conference concluded that:

Rust is sure to conduct an epoch-making experiment in the Linux kernel.
The entry of Rust into the Linux kernel is of strategic significance to the evolution of Rust.

On November 11, 2021, another webinar was posted on the Linux Foundation website: Rust for Linux: Writing security abstractions and drivers, Miguel Ojeda explains how Rust works in the kernel, including overall infrastructure, build models, documentation, testing and coding guidelines.

I made a brief summary of this video:

This section describes Unsafe Rust and Safe Rust.
The idea behind using Rust in the Linux kernel is to encapsulate the Unsafe operation and provide a security abstraction for kernel developers to use. The security abstraction is locatedGithub.com/Rust-for-Li… 的 kernelIn the module.
Give a simple example of how to write a kernel driver
Compared with the C language example, what is Safety behavior in Rust is given.
Documentation, tests, and coding guidelines to follow are described.

An updated patch was released this morning describing the initial support and infrastructure for handling Rust in the kernel.

This update includes:

Upgraded to the latest Stable compiler and Rust 2021 Edition. So we can get rid of itconst_fn_transmute.const_panic,const_unreachable_unchecked,core_panic 和try_reserveThese were previously unstable properties.Unstabilized feature wish sheet.
The customcore 和 alloc. forallocMore modular options have been added to disable some functionality they don’t need:no_rc 和 no_sync, mainly added for upstream Rust projects.
Stricter code, documentation, and newlint.
Abstractions and driver updates. Added abstractions for sequence locking, power management callbacks, IO memory (readX/writeX), IRQ chips and advanced stream handlers, GPIO chips (including IRQ chips), devices, AMBA devices and drivers, and certificates. In addition, it has been improved and simplifiedRef(refcount_tSupported) object and replaces Rust’sArcAll instances of. Completely from theallocIt was removed from CrateArc 和 Rc.

From now on, the Rust for Linux team will start submitting patches regularly, every two weeks or so.

In addition to support from Arm, Google and Microsoft, this time the team received a letter from Red Hat: There is also interest in using Rust for kernel work that Red Hat is considering.

V2 patch: https://lore.kernel.org/lkml/[email protected]/
www.phoronix.com/scan.php?pa…
The kernel crate document

Given what we’ve learned above, it’s likely that 2022 will see experimental Rust programming language support in the Linux kernel go mainstream. If this experiment is successful, Rust has officially taken over the REINS from C.

Redox + Theseus

Redox is a minix-like microkernel design implemented by pure Rust, which provides memory allocators, file systems, display managers, core utilities, and so on that together make up a functional operating system.

The originator of Redox works for System76, but the Redox project is not actually sponsored by System76. I used to think that Redox was a commercial open source project for System76, but recently I found out that Redox is funded by community sponsorship. The main expenses of Redox are basically for the Summer of Code of Redox OS, recruiting some students and improving its functions.

One of the more important developments for Redox in 2021 is the announcement of Theseus, another rust-implemented operating system, to join Redox.

In modern OS, different processes share a lot of state, which can cause problems with state spill. For example, if an Android system service fails, the “entire user-space framework” crashes, affecting all applications, even those that don’t use the failed service.

Theseus OS has many tiny components called units, each with clear boundaries. Each unit is a Rust Crate. The bigger innovation, however, is what they call “Intralingual operating system design,” which they mean using programming language mechanisms to implement an operating system, i.e., “transforming semantic errors from runtime errors to compile-time errors.” This means that Theseus has a closer relationship with Rust than any other OS.

Theseus OS fault recovery involves replacing damaged units with new ones. The researchers claim that this “allows Theseus to tolerate failures in the lowest system layer when faced with multiple failure subsystems.” It’s a unit switching technology. Maybe that’s where the name Theseus came from. You know the story of the Ship of Theseus?

The embedded OS

Tock OS 2.0

Tock is an embedded operating system designed to run multiple concurrent, untrusted applications on embedded platforms based on Cortex-M and RISC-V. Tock is protection-centric in design, both to protect against potentially malicious applications and device drivers. Tock uses two mechanisms to protect different components of the operating system. First, the kernel and device drivers are written in Rust, a system programming language that provides compile-time memory safety, type safety and strict aliasing. Tock uses Rust to protect the kernel (such as the scheduler and hardware abstraction layer) from platform-specific device drivers and to isolate device drivers from each other. Second, Tock uses memory protection units to isolate applications from each other and the kernel.

Google released OpenSK on top of Tock! OpenSK is an open source implementation of a security key written in Rust that supports both the FIDO U2F and FIDO2 standards.

One of the moves of Tock OS this year is that it has been upgraded to version 2.0, and this is a major update with a completely new kernel and a redesigned core kernel API.

And the basic coverage of chip and development board support is very comprehensive: RISC-V/ARM CortexM0+ / ARM CortexM7 / Nano RP2040 / Rapsberry Pi Pico/ ESP32-C3-devkitm-1, etc.

Hubris

Hubris has no runtime create or destroy task operations, no dynamic resource allocation, no driver code running in privileged mode, and no C code in the system. With this construction, many of the attack surfaces that normally exist in similar systems are eliminated.

Rust will be part of the upcoming firmware revolution, as mentioned by OXide in its share of the upcoming firmware revolution at this year’s OSFF Mini Summit 2021. So they took a fresh look at the embedded operating system and developed Hubris with Rust. Hubris currently only supports the Arm Cortex M platform.

Hubris vs TockOS:

Tock uses dynamic loading, Hubris is static
Tock is very asynchronous, Hubris is strictly synchronous
Tock’s drivers are in the same preserve as the kernel, and Hubris’s drivers are in a different projection domain

other

A new failure,

Wind River VxWorks is a deterministic, priority-based preemptive real-time operating system with ultra-low latency and minimal jitter. In its latest release, it announced the only real-time operating system supporting C ++ 17, Boost, Rust, Python, pandas, and other development languages.

Google Fuchsia

In May 2021, Google Fuchsia OS was officially released, and by December Fuchsia will be running on the second device (Nest Hub Max).

As we all know, nearly 30% of Fuchsia’s code is implemented by Rust. Fuchsia programming Language Policy analysis of Rust:

Advantages:

The Fuchsia platform source tree has a positive implementation experience with Rust.
The language provides a memory security guarantee, which reduces the risk of security vulnerabilities in software developed with the language.
You can write asynchronous programs using linear code.
The Fuchsia project has the opportunity to influence language development.

Disadvantages:

Rust is not yet a widely used language.
None of our current terminal developers use Rust.

So the final decision:

Terminal developers do not currently support Rust.
Rust is approved for use throughout the Fuchsia platform source tree, with the exception of:
- The kernelThe Zircon kernel is built using a limited set of technologies that have established an industry track record for use in production operating systems.

Cloud native

Linkerd2

2021 will be a banner year for Linkerd. The project graduated in the Cloud Native Computing Foundation, which represents the highest level of project maturity. Linkerd adoption has soared this year, with a wide range of organizations, including Microsoft, S&P Global, and the Norwegian Labor and Welfare Administration, among many others, openly adopting Linkerd.

Linkerd 2.11 was released in September 2021 and more components migrated to Rust. In version 2.11.0, Linkerd has introduced a new policy controller component written in Rust. It uses Kube-RS to communicate with the Kubernetes API and exposes a gRPC API implemented by Tonic.

Although Linkerd has a lot of Rust experience on the data side, they chose Go as the control side component because the Kubernetes ecosystem (and its API clients, etc.) is so heavily skewed toward Go. However, thanks to u/ Clux’s excellent work on Kube-RS, it has now become feasible to implement the controller with Rust. This is a big step forward for the Linkerd project, which plans to make more use of Rust throughout the project. It publishes benchmarks that show performance and resource usage an order of magnitude ahead of Istio; It continues to lead the way in bringing Rust into the cloud native space. They hope that this new direction for Linkerd will help welcome more contributors who want to grow their Rust practice experience.

If you’re interested in Linkerd2’s 2022 roadmap, you can click here.

DeislabsThe project of

Akri

Akri is a sandbox project of the Cloud Native Computing Foundation (CNCF) to provide edge computing solutions for Kubernetes. Akri aims to be the standard way to use iot devices on edge Kubernetes clusters, which is why Akri in Greek not only means “edge” but also stands for Kubernetes resource interface.

Krustlet

Krustlet is a Kubelet implementation that enables users to run WebAssembly and traditional container workloads in the same Kubernetes cluster.

In 2021, Krustlet and krator project (Kubernetes Rust State Machine operation framework) became CNCF’s sandbox project. So far, version 1.0-alpha.1 has been released, with official version 1.0 coming soon.

So what does this 1.0 mean? It implies stability and backward compatibility guarantees. People can start building real products out of it. More features will be added later as WebAssembly and WASI mature.

WebAssembly ServerSide with edge computing

Lucet

According to the Fastly 2021 review article:

Daily request traffic for Compute@Edge experienced explosive growth in 2021, skyrocketing over 31,000% from January’s daily traffic. Customer usage is on pace to reach 2 trillion total requests across 2021, with a target to reach 50 trillion requests by the end of 2022.

In 2021, Compute@Edge experienced explosive growth in daily request traffic, jumping more than 31,000% from January’s daily traffic. Customer usage is expected to reach 2 trillion total requests in 2021, with a target of 50 trillion by the end of 2022.

Compute@Edge is an edge computing platform for Fastly, which runs custom binaries that you compile and upload to Fastly on your own system. They provide security and portability by compiling the code into WebAssembly, which they run on the edge using Lucet, an open source WebAssembly runtime created by Fastly. Lucet is implemented based on the WasmTime WebAssembly runtime of the Bytecode Consortium.

other

There are many other innovative products in the WebAssembly Serverside space:

WasmEdge is a lightweight, fast and mission-critical code runtime for edge computing and software-defined vehicles. The goal is to dramatically reduce complexity and speed up development. It is currently the fastest Wasm VIRTUAL machine on the market and was developed by Cpp, but is currently working on the Rust SDK that will fully embrace Rust.
WasmCloud, a WebAssembly-based distributed computing platform, is also a CNCF sandbox project. What is more innovative is that it develops a waPC standard for secure procedure calls for Guest and Host to solve the current problem of imperfect features such as WASI.

Rust has been used by ByteDance’s flying books, security, and infrastructure departments, and has open-source some of the base libraries.

Among them, the outstanding basic libraries that can be used for cloud native projects are:

Monoio, an asynchronous Runtime based on the IO -uring thread-to-per-core model, is described in design and Implementation of the Rust Asynchronous Runtime.
Keyhouse, a key management system for internal use in bytes, is open source on Github and supports encryption, decryption and sensitive configuration management. At present, many businesses in Byte are developed based on this system.

Internet of Things

Rust Embedded Working Group progress

The first RP2040 microcontroller comes with two Cortex M0 cores. This led members of the working group to think about how to provide security in multi-core microcontrollers, which led to the RP-RS organization.
Mabez was hired by Espressif to develop Rust support for ESO chips: ESP-RS
Other platforms increasingly support Rust, including: Atmel ARM SAM-D and SAM-E, Atmel AVR, NXP ARM IMX. RT microcontrollers, ARM nRF51, 52 and 9160 Bluetooth /LTE devices, RISC-V, Raspberry PI, STM32, and more.
Embedded Rust ecology has made great progress:
- The embedded concurrency framework RTIC has been 1.0
- Embedded asynchronous framework Embassy is being developed to support STM32, nRF, and RP2040 platforms and is also heavily influenced by Rust asynchronous improvements
- Knurling, an embedded development and debugging tool, has released a new probe tool
- The embeddedTCP/IPThe stacksmoltcpA new version has been released
- A new version of embedded graphics library embedded- Graphics has been released
- New embedded real-time OS Hubirs open source.
The embedded working group’s own maintenance project was also vigorously developed and maintained this year.

See more: blog.rust-embedded.org/this-year-i… .

Overall, Rust is becoming more mature in the embedded space.

Development of Espressif ESP-RS

In 2021, The company announced that mabez had been hired to work full-time on Rust support for ESP32, the GitHub counterpart to ESP-RS. This means Rust will be fully in the ESP32 space.

By the end of the year, Mabez’s work can be seen on his blog. Overall, the progress so far is:

esp-rs book
Probe-rs support for ESP32C3 is now more complete
Espflash reached 1.0
Introducing esp32 – Hal
And so on

More updates can be found in Rust on Espressif CHIPS – 10-01-2022. Have to say, Lexin is a very farsighted company.

trend

ARM, by far the leading manufacturer of embedded devices such as chipsets and sensors used at the edge of the Internet of Things, has joined the Rust Foundation this year.

Rust is fully capable of performing specific tasks in higher level iot domains such as embedded computing, such as the implementation of edge lightweight computing and back-end services, while meeting the functional security requirements of such iot infrastructures to a certain extent.

As the iot related parts of its ecosystem continue to evolve, even lack some significant foundations, and are far from stable. But on the plus side, we see companies like Drogue, Ferrous Systems, and other independent companies pushing Rust into the iot space actively developing critical infrastructure and bringing a brighter future to Rust.

The game

GPU graphics rendering worthy of attention

rust-gpu

Rust-gpu is an open source project by Embark Studios that aims to make Rust the first class language in graphical rendering. Currently working with Traverse Research to build rust-GPU.

Embark is partnering with South Korean gaming company Nexon (Adventure Island, Go-Kart Run). Embark is former EA chief design officer Patrick, who was the CEO of Battlefield developer DICE. Embark is also a member of the Rust Games Working Group, and the company has sponsored many of the authors of Rust Eco-open source projects.

Traverse Research is located in the heart of Breda, the Netherlands, with a vision to make Breda a powerhouse for game development. The core members of the team are highly proficient in graphics.

Rust-gpu is aimed primarily at graphics rendering engines, hoping to introduce Rust as a coloring language. This is accomplished by compiling the RUSTC back end to Spir -V, the binary intermediate language for shaders. Currently the most common ones are GLSL/HLASL, but they didn’t provide a mechanism for handling large code bases as the game industry grew, so there was an urgent need for a good coloring language in this space, and the folks at Embark thought Rust was the best choice, so they did it.

Embark has also opened source an experimental global lighting rendering engine, Kajiya, based on rust-GPU.

Rust-CUDA

Rust-cuda is a project that aims to make Rust a Tier 1 (Tier-1) language for extremely fast GPU computing using the CUDA toolkit. With this project, the team hopes to move the Rust GPU computing industry forward and make Rust an excellent language for such tasks. Rust offers many benefits, such as efficient utilization of the performance benefits of each kernel, a great module/Crate system, separating unsafe areas of CPU/GPU code with Unsafe, and building advanced wrappers for the underlying CUDA libraries.

WGpu

The goal of the GFX-RS community is to make graphical programming in Rust simple, fast, and reliable. Major projects include:

wgpuBased onwgpu-halandnagaAbove the law. It provides security, accessibility, and portability for graphical applications.
Naga, shader language translation library, including WGSL. It also provides shader validation and conversion to ensure that user code running on the GPU is secure and efficient.

Development of WGPU in 2021:

Gfx-hal migrated to the newly createdwgpu-halAnd reorganized the repository to put everything together.
wgpuwithDenocloselyintegration.
In terms of correctness and portability, the hard work of ensuring that all resources are zero initialized correctly is done. This turns out to be more complicated than it seems, and now users will get consistent behavior across platforms.

Naga 2021:

Added more back ends (HLSL, WGSL) and greatly improved desktop support
Abandoned SPIRV – Cross

The best in game engines

Bevy

Bevy is a data-driven game engine based on Rust implementation. Compared to other game engines implemented by Rust, such as Amethyst, Bevy is a late comer. Bevy has a unique API design that takes full advantage of the Rust language to make it easy for developers to get started. Thanks to its Plugin mechanism, Bevy has gradually formed its own ecology and many Plugin based on Bevy have emerged.

As an open source project, Bevy has almost reached its goal of $6,000 per month on GitHub. Although Bevy has only released version 0.6 at present, its ecosystem is gradually established, and it is welcomed and expected by many people.

There are a number of improvements, bug fixes and quality improvements in Bevy 0.6. Here are some of them:

A new modern renderer that is prettier, faster and easier to expand
Native WebGL2 support. You can test it by running the Bevy example in a browser!
More powerful shaders: preprocessor, import, WGSL support
Bevy ECS ergonomics and performance improvements. Without the.system()!

See introduction to Bevy 0.6 for more.

By the way: Domestic companies are already applying Bevy to commercial projects and hiring.

Fyrox(Rg3d)

Fyrox(RG3D) is another Rust implemented game engine that supports BOTH 3D and 2D. The project was previously called RG3D, now renamed Fyrox.

The game engine, while not as popular as Bevy, is growing rapidly, with a 0.24 release date. Change in a nutshell:

2 d support. From the beginning, the engine was only focused on 3D games, but in RG3D 0.23 things changed a bit, adding a simple 2D version of the scene.
Added a development guide
Physical integration
The sound engine RG3D-Sound was introduced

See rG3D 0.24 feature highlights for details

Amethyst new start

The Amethyst Engine has announced the end of development and the torch of the game engine has been passed to Bevy. In the future, the Amethyst Foundation will continue to create value in the game field, but not just in the game engine.

Why is that?

Amethyst has never found its footing since moving from a top-down BDFL model to a flat peer-to-peer model. There was a lack of consensus within the team about Amethyst’s goals.
The Bevy engine is well developed and will pass on the Amethyst torch.

What the Amethyst engine does well: By building an advanced, ECS-powered game engine, hundreds of Rust game developers connect with each other through Amethyst and form lasting friendships.

BDFL: BDFL is an abbreviation For Benevolent For Life. The Chinese translation is “benevolent dictator for life”. Under this structure, one person (usually the original author of the project, or a person elected by the community) owns all final decisions on the project. Smaller projects may default to a BDFL structure, since such projects typically consist of one or two maintainers. If the company organizes the project, it is very likely to adopt BDFL structure, so as to control the decision-making power of the project.

The future of the Amethyst

Amethyst has already established a foundation that will continue to invest in games despite the end of game engine development. But the future will not focus solely on making any particular game engine.

The next step may be to help new Rust game developers enter the field with efforts such as promotion, coordination, education, community building, etc. And some of the things the Amethyst team is doing right now are not engine related, like Distill, Specs, Legion, Laminar, etc.

Note: Amethyst just stopped game engine development, but they are moving into the broader Rust game development space to do something much more valuable.

other

Quilkin

Quilkin is a UDP proxy developed by Google Cloud in collaboration with Embark Studios, tailored for high-performance real-time multiplayer games to provide a standard, open source solution. The purpose is twofold:

Take security, access control, telemetry, and metrics out of a single dedicated game server and client.
Provide these common features in a composable and configurable manner so that it can be reused in a wide range of multiplayer games.

In general, let Quilkin help protect the server from attack by absorbing invalid traffic, or run on the edge to provide optimal latency for player traffic. This is great for any game studio, which can have the same online capabilities as the big giants.

Rapier

Rapier is a 2D and 3D physics engine written by Rust for gaming, robotics and animation. A new version was released in 2021 with many new improvements. The focus of this release is support for multi-body joints.

According to the CTO of Resolution Games, the Rapier physics engine is used to build VR Games with Rust.

The data processing

Databend data cloud

Databend is designed to be an open source resilient and reliable cloud repository that provides extremely fast queries and combines the flexibility, simplicity, and low cost of the cloud to make the data cloud simple.

Databend is clickhouse-inspired with a computing model based on Apache-Arrow. Databend implements an elastic, fully cloud-oriented architecture design that emphasizes the separation of state and computation. Databend offers a lower cost, easier to use, pay-as-you-go experience than traditional databank. Databend iterates toward Serverless. Serverless means that the scheduling of resources can be more refined. The computing nodes of cloud database can be like a function, which can be pulled up when used and destroyed after use. It only needs to pay for the use, and the scheduling of resources will be very accurate.

Data flow processing

Tremor

Tremor is an event handling system. It was originally designed as an alternative to software like Logstash or Telegraf. However, tremor moves beyond the scope of this single use case by supporting more complex workflows such as aggregation, summary, ETL language, and query language.

Tremor runs 24×7 365 days per year and is implemented using the Rust programming language.

Digging a little deeper into the company behind the Tremology-Runtime project, it turns out to be Wayfair. Wayfair is the largest furniture e-commerce company in the United States, with a market capitalization of $5.8 billion in 2017. It was founded as CNSStores in 2002. Amazon couldn’t eat it.

Wayfair’s Tremor is an open-source project already available on CNCF. A small online Tremor Conf was also convened in September 2021

How Rust can save Wayfair thousands of cores and TERabytes of memory: 2020-03-31- Rustandtellberlin-Functions

As of 2018, the Wayfair tremor movement is a wayfair production environment that processes 10 megabytes of data per day, or 10 billion messages per minute, and 10 million metrics per second. Tremor reduces cost, reduces complexity, consolidates and simplifies the operating environment to stimulate SRE fun, reduce NOC workload, and reduce operating costs.

Real-time analysis of the streaming database Materialize

Materialize is a reactive database that provides incremental view updates to help developers easily build streaming data using standard SQL. Incremental computation can be achieved by simply describing the computation with a standard SQL view and then connecting Materialize to the data flow without the need for complex data pipelines. The underlying Online Analysis of Distributed Dataflows with Timely Dataflow is capable of performing incremental calculations to provide consistent and correct output with minimal latency. Unlike a traditional database, there are no restrictions on defining the View of Materialize, and calculations are performed in real time.

The company has raised $40 million in Series B funding.

other

Fluvio: Is an open source data streaming platform that aggregates, correlates, and applies programmable intelligence to dynamic data. Fluvio is powered by Rust to provide a low-latency, high-performance programmable flow on top of a cloud-native architecture.
Vector: A lightweight, ultra-fast tool for building observable pipelines.

Figure database

Sea star map: financial level distributed high performance map database

Haizhi Star Map is a domestic company committed to financial level map platform products, the company has used Rust for the development of high performance distributed map database. Currently not open source.

As far as I know, this product is used in epidemic prevention scenes to find out the correlation between people, people and places, and people and vehicles in the first time, and extract valuable relationship chains, which plays a crucial role in blocking transmission chains and timely finding close contacts.

Machine learning and scientific computing

2021 NLP star project, Transformers

Select Face, a Chatbot startup based in New York, us. The company is a big name in the NLP world, having just raised a $40 million Series B round in March 2021. GitHub has released Transformers, an open source NLP library that integrates Tokenizers.

Tokenizers are Rust’s tokenizers, which enable 1GB of text processing on a select server CPU in less than 20 seconds. One of the bottlenecks in the modern NLP pipeline based on deep learning is tokenization, especially the implementation that is versatile and framework-independent. So, the core of the tokenizer is written in Rust, and there is a Node and Python binding. Provides implementations of today’s most commonly used word dividers, with emphasis on performance and versatility.

Transformer models are widely used by tesla, Google, Microsoft, Facebook and other tech giants. Transformer drives cars in Tesla’s AutoPilot system, completes sentences in Gmail, translates users’ posts on Facebook and answers users’ natural-language queries in Bing.

Arguably, the startup’s use of Rust to build its word segmentation seems to be intrinsically beneficial to both the accuracy and performance of its machine-learning models.

linfa

Linfa is a Rust-implemented Library similar to Python Scikit-Learn designed to provide a comprehensive toolkit for building machine learning applications using Rust. The team also created rust-ML.

Scikit-learn, also known as SkLearn, is an open source Machine learning toolkit based on python. It uses python’s NumPy, SciPy, and Matplotlib libraries for efficient algorithmic applications and covers almost all major machine learning algorithms.

More information: The Book of Rust Machine Learning

The library has released version 0.5 of its Roadmap for 2021, with 20 of the 24 tasks it has accomplished so far. The Roadmap aims to be fully functional with Python’s SciKit-Learn algorithm, which is based on a branch of SciPy developed for machine learning. At present, only Gaussian process, random forest, ensemble learning and minimum Angle regression remain to be completed. This Roadmap has been developed for about two years and should be completed by 2022.

That is, in 2022 there will be a library in the Rust ecosystem that does exactly what Python SkLearn does, but performs better than skLearn.

Polars

On the data manipulation level, everyone likes Pandas’ API. It’s fast, easy and well-documented. But on the production side, Pandas is a bit tricky. Pandas does not extend well… No multi-threading… It’s not thread-safe… It’s not memory efficiency. All this is Rust’s raison d ‘etre.

Polars is a new Dataframe library implemented in Rust with convenient Python bindings. It attempts to read, write, filter, apply functions, group, and merge in a thread-safe manner. It uses Apache Arrow, a data framework specifically built for efficient data processing and data sharing across languages.

Polars has two advantages:

It’s a performance killer, see DB-benchmark.
Its API is very simple. You don’t have to understand Rust syntax to understand what the interface is doing.

It also has three disadvantages:

Building the Dataframe API was difficult, it took Pandas 12 years to get to 1.0.0, and Polars is young, so it’s not mature yet.
To use it, you need to be familiar not only with the Polars API, but also with the Arrow API, since Arrow does much of the heavy lifting.
The compilation time is too slow, probably around 6 minutes.

Polars is now sponsored by Xomnia. Xomnia is a Dutch artificial intelligence company working on self-driving ships, known as Teslas on the Water.

oxide-enzyme

Oxide-enzyme is another new project created by the Linfa team at the end of 2021. Oxide-enzyme is a Rust front-end library for enzymes that is currently experimental but under active development.

Enzyme is an automatic differential framework proposed by MIT that synthesizes the gradient of a static analyzable program in the form of LLVM intermediate representation (IR). Enzyme can synthesize gradients of any program written for LLVM IR compiler languages, including C, C ++, Fortran, Julia, Rust, Swift, MLIR, etc. to provide native AD functionality for these languages.

The context in which Enzyme appears

Machine learning frameworks such as PyTorch and TensorFlow have become important tools for development. When calculating gradients for algorithms such as back propagation, Bayesian inference, quantization of uncertainty, and probabilistic programming, we need to write all the code into the framework in differential form. This creates problems for introducing machine learning into new domains: in physics simulations, game engines, climate models, the original domain components are not written by the domain-specific language (DSL) of the machine learning framework. Thus rewriting requirements becomes a challenge when introducing machine learning into scientific computing.

To address this, trends include building new DSLS to make the rewriting process easy, or building directly at programming time. These methods allow us to obtain effective gradients, but still need to be rewritten using DSL or differentiable programming languages. To make things easier for developers, researchers from MIT open-source enzymes.

MegFlow

MegFlow is a streaming computing framework for computer vision applications that megvii opened source in September 2021. MegFlow provides a set of visual parsing services for rapid DEPLOYMENT of AI applications. AI application developers can customize features such as invoice scanning and open fire detection in as little as 15 minutes based on MegFlow’s image and video parsing services.

The conventional AI algorithm delivery process is generally divided into four steps: model training, SDK packaging, business integration and delivery acceptance. MegFlow summarizes megmegflow’s years of experience in AI application project implementation, clearly and consistently abstracts concepts such as resource, message and task, and simplifies the long algorithm delivery process into three steps: model training, business integration and delivery acceptance. With MegFlow, AI algorithm researchers can quickly integrate and deploy trained models into easy-to-use AI services and deliver them.

MegFlow’s R&D team investigated a variety of technical solutions, and finally chose Rust asynchronous ecology, which is safe and has no extra cost, to ensure the security and performance of MegFlow.

MegFlow has been open source for four months now and has added a few new features, as well as a new use case: a cat fence. Programmers have created an artificial intelligence cat food machine! , the experimental results are good. Developers can also apply for free computing power from Megvii.

Qdrant: Neural network search engine

Qdrant is a vector similarity search engine. It provides a production-ready service with a convenient API for storing, searching, and managing points (vectors with extra payload). Qdrant is customized for extended filtering support. This makes it useful for all kinds of neural networks or semantically based matching, faceted search, and other applications. Based on Rust implementation, performance is also guaranteed. Embedded neural network encoders can become full-fledged applications for matching, searching, recommending, and so on.

other

Here are a few machine learning frameworks that are still active in maintenance, as of June 2021:

Tch-rs is a Rust binding of Pytorch’s Cpp API that is currently under active maintenance.
Ndarray is an open source project developed by Bluss, a senior scientific computing expert on Rust’s official team, which implements matrix and linear arithmetic based on Rust. The goal is to build a scientific computing community in Rust similar to Numpy and OpenBLas. It is the base of machine vision, data mining, biological information and other scientific computing libraries. The main users in the community are universities or research institutes of some related technologies. Huawei is also heavily involved in the library’s development.
Nalgebra, Rust’s general-purpose linear algebra library, was developed along with Rapier by the Dimforge open source organization.
Tvm-rs is the Rust binding of TVM, a deep learning automatic code generation method proposed by University of Washington PhD candidate Tianqi Chen and others, which was briefly introduced by Heart of Machine last August.
Neuronika is a machine learning framework written in Rust, similar to PyTorch, that already implements the most common layer components (dense layer, Dropout layer, etc.) at speeds comparable to PyTorch.
Whatlang, a natural language recognition project based on Rust implementation.

GUI

GUI project to watch for 2021: SixtyFPS

SixtyFPS is a toolkit that effectively develops a smooth GRAPHICAL user interface for any display: embedded devices, desktop applications, mobile, and the Web (currently compiled to WASM, but only as a demo, SixtyFPS has no intention of using the Web as its main competitive platform). It supports multiple programming languages, currently Rust, C++, or JavaScript. The core library is implemented in Rust, and support for other languages is done through the C-ABI.

Starting in 2021, we’ve seen an increase in the number of startups based on Rust and open source, including the GUI-focused SixtyFPS, which is an open source GUI tool library for all platforms. One of the goals is to replace Qt, in other words, SixtyFPS is basically the next generation QML that most Qt developers have been waiting for.

Both SixtyFPS founders have deep experience in Qt development. One of them worked as a lead developer and maintainer of the QtQml engine at Qt.

Looking at their 2021 summary report, I found that they registered their company in 2021, established a partnership with a consulting firm like tQCS, found their first client and recruited new members. (Feel foreign technology flow entrepreneurship and domestic or a little different). TQCS provides the number one Qt consulting and UI/UX design service in the world. What does it mean to partner with SixtyFPS? That’s a matter of opinion.

In 2022 they will probably have a big embedded support and a new brand name.

Tauri

Tauri is seen as a replacement for Electron, both of which are frameworks for creating desktop applications using Web technologies to develop application user interfaces. Although the two appear to be the same, they are very different.

Here’s a comparison:

Bundle size: Tauri is about 19 times smaller than Electron.

Framework	OS	Bundle size (installer)	Main executable size
Electron 15.3.0	Windows 11 x64	83 MB	137 MB
Tauri 1.0.0 – beta. 10	Windows 11 x64	7MB	4MB
Electron 15.3.0	Linux x64	114 MB (deb)	134 MB
Tauri 1.0.0 – beta. 10	Linux x64	6.5 MB (deb)	16 MB

Memory consumption: Electron is 9 times higher than Tauri.

Framework	OS	Number of processes	Total RAM used
Electron 15.3.0	Windows 11	4	138 MB
Tauri 1.0.0 – beta. 10	Windows 11	8	110 MB
Electron 15.3.0	Linux x64	18	224 MB
Tauri 1.0.0 – beta. 10	Linux x64	1	23 MB

Performance: Tauri is superior

Framework	OS	First launch after build	Second launch
Electron 15.3.0	Windows 11	9940 ms	1420 ms
Tauri 1.0.0 – beta. 10	Windows 11	1230 ms	1120 ms
Electron 15.3.0	Linux x64	2570 ms	1910 ms
Tauri 1.0.0 – beta. 10	Linux x64	1560 ms	1130 ms

However, tauri is more demanding and the Tauri API is not nearly as complete and fleshy as Node.js, so you may need to implement some of the apis yourself using Rust when using Tauri.

The comparison of the above from: githubhelp.com/Fournux/tau… .

In addition, Tauri incubated two more Crate in 2021:

Wry, a cross-platform WebView library.
Tao, a cross-platform Window library.

Tauri is currently in beta 1.0 and is not far from a stable release. Tauri chose Rust for security and performance reasons. Tauri promises to provide you with a safe baseline, whether you’re building a Localhost server into your App or doing something else. Other backend languages such as Go, Nim, Python, and Csharp will also be supported in the future, all through the c-API provided by the current Rust kernel.

Egui

Egui is a GUI framework implemented purely in Rust that uses immediate Mode (drawing the DESIRED UI on the screen in real time). The advantages and disadvantages of this immediate mode are explained in the EGUI README, which you should check out if you are choosing a model. In short, the immediate pattern contrasts with the reserved pattern. The main advantage of immediate mode is that the application code is very simple, but the disadvantage is that the layout is more difficult, and the GUI cannot be too complex, otherwise it will burden the CPU.

A Reddit user said they were using Bevy and Egui to build commercial CAD software.

As of now, eGUI has released version 0.16.

other

Gtk4-rs, another active GUI library is THE Rust Binding for GTK. Gtk4’s Rust Binding gTK4-RS 0.3.1 was released in 2021 and is currently under active maintenance.
Iced, a GUI framework influenced by the Elm architecture, is based on wGPU. It’s also cross-platform, including the Web UI. 2021 has been under active development, but no new version has been released in the eight months since the release in April 2021. But it is also a promising framework.
Druid, an experimental Rust native UI toolkit, is worth watching. Druid’s current development has been largely driven by its use in Runebender, a new font editor (in its very early stages).
Azul is a cross-platform desktop GUI framework. It mixes functional, reactive, and data-oriented programming paradigms with apis for developing cross-platform desktop applications. The two core principles of Azul are not to render invisible objects and to use combinations of DOM trees rather than inheritance. Currently there is a 1.0-alpha release, and the official 1.0 release is not far off.
Lvgl-rs is the Rust binding of LittlevGL. Littlevgl is a GUI written in pure C with beautiful controls that are easy to transplant from a display interface to a touch control interface.

Web and Web development

Network services

As the world becomes more connected, the size and complexity of network infrastructure software is increasing dramatically. However, the requirements for the software are as strict as ever: not only must it be fast, but it must also be “secure”, meaning able to handle untrusted data without crashing or being vulnerable to security breaches. Traditionally, the two requirements were at odds: Web programmers had to choose a language that provided both speed and security. So Rust is a necessary language for the next generation network infrastructure.

Tokio

Tokio, a mainstay of the current Rust ecosystem for building web services, is a Rust asynchronous runtime and network application framework. While there are other asynchronous runtimes in the Rust ecosystem, such as Async-STD, Tokio is definitely the most ecologically mature one.

Tokio does a lot of work on security, performance, and asynchronous task scheduling, with support for epoll and IO_URING (tokio_uring just released version 0.2). There is also tracing, Console (asynchronous debugging, just released version 0.1), and Loom (concurrent testing) tools.

While Rust asynchrony still needs a lot of work, it is now possible to use Rust asynchrony in a production environment thanks to Tokio.

Lunatic

Lunatic, is a WebAssembly runtime influenced by Erlang. You can use it as a fast, robust, and extensible server-side application, but you can use it from any language that compiles to WebAssembly.

Lunatic concurrency is based on ultra-lightweight processes, similar to Green threads or Go-Routines. The Lunatic processes can be created quickly, occupy small memory, and have low scheduling overhead. They are designed for large-scale concurrency. It is not uncommon to see hundreds of thousands of such processes running simultaneously in a typical application. Lunatic processes are completely isolated from each other, with their own stacks, heaps, and even system calls. If one process fails, it does not affect the rest of the system. This allows developers to create powerful and fault-tolerant abstractions.

All processes running on the Lunatic are scheduled and executed by preemptive asynchronous execution (smoL based implementation). This gives the developer the freedom to write simple blocking code, but the runtime will ensure that it doesn’t actually block the thread while waiting for I/O.

Even if an infinite loop exists somewhere in the code, scheduling will always be fair and will not permanently block the thread of execution. The best part is that developers don’t have to do anything special to achieve this, the runtime handles it no matter which programming language you use.

All of this is based on Rust and WebAssembly (WASmTime and WASmtime-WASI), which has only released version 0.7.0 and is still iterating at a high rate.

Embassy, embedded asynchronous runtime

In embedded, interrupts, DMA, and multiple cores are typically used to process concurrent events without blocking the main loop. These have traditionally been handled by intentional register writes. For example, a command is sent to a peripheral to start a task, the program continues to run, and when the task is complete, an interrupt is triggered and the code that processes the completion runs immediately. These processes can be abstracted in Rust using future-based Async/Await capabilities.

Embassy is a project designed to make Async /await the first choice for embedded development. Asynchrony results in better performance and lower power consumption because the actuator does not have to guess when it will be ready to execute in the future. However, the program size can be larger than other alternatives, which can be a problem for some space-constrained devices with very low memory. On Embassy supported devices, such as STM32 and NRF, memory is usually large enough to accommodate a modest increase in program size.

Embassy is an executor and a hardware access layer (HAL). An executor is a scheduler that typically performs a fixed number of tasks assigned at startup, but more can be added later. HAL is an API that CAN be used to access peripheral devices such as USART, UART, I2C, SPI, CAN, and USB. Embassy provides implementation of asynchronous and blocking apis where it makes sense. DMA (direct memory access) is a good example for asynchrony, while GPIO state is better suited for blocking apis.

Embassy can also provide a system timer that can be used for asynchronous and blocking delays. For less than a microsecond, blocking delays should be used because the cost of context switching is so high that the actuator will not be able to provide accurate timing.

Embassy currently offers HAL for several microcontroller families:

embassy-nrfNRF microcontroller for Nordic Semiconductor
embassy-stm32STM32 microcontroller for ST Microelectronics
embassy-rpSuitable for Raspberry Pi RP2040 microcontroller

The ASYNCHRONOUS trait support in Embassy is an MVP implementation of the Rust Async trait to be officially supported in the future:

pub trait I2c<A: AddressMode = SevenBitAddress> {
    /// Error type
    type Error;
		// Based on GAT (nightly Rust)
    type ReadFuture<'a>: Future<Output = Result<(), Self::Error>> + 'a
    where
        Self: 'a;
		
    fn read<'a> (&'a mut self, addr: A, bs: &'a mut [u8]) -> Self::ReadFuture<'a>;
}

impl<A: AddressMode = SevenBitAddress> I2c<A> for u8{
      fn read<'a> (&'a mut self, addr: u8, bs: &'a mut [u8]) -> Self::ReadFuture<'a> {
          // Use async move
        	async move {
              // implementation}}}Copy the code

When GAT stabilizes (projected in Q1 2022), Rust Embedded asynchronous ecosystems will soon be enriched.

EBPF stable support

EBPF is a set of general purpose execution engines that can sandbox programs in the Linux kernel. EBPF provides the general ability to execute specific code efficiently and safely based on system or program events. The users of general ability are not limited to kernel developers.

EBPF is also increasingly playing an important role in observation (tracking, performance tuning, etc.), security and networking. Well-known Internet companies such as Facebook, NetFlix and CloudFlare have widely adopted various programs based on eBPF technology for performance analysis, troubleshooting, load balancing, and anti-ddos attacks. A number of eBPF tools are built into the Facebook machine, according to the information.

The performance of eBPF technology in network technology is more impressive. The combination of BPF technology and XDP (eXpress Data Path) and TC (Traffic Control) can achieve more powerful network functions.

Redbpf is Rust’s repository of tools for building and running BPF/eBPF modules. It contains many components that make eBPF functionality easier to use. Updates are also very active, with version 2.3.0 just released a week ago. Infinyon uses it to route traffic.

Other actively maintained libraries and frameworks

Monoio, an asynchronous Runtime based on the IO -uring thread-per-core model, was introduced in the previous article. See Design and Implementation of the Rust Asynchronous Runtime for more details.
Glommio, another asynchronous Runtime based on the IO -uring Thread-to-per-core model from DataDog open source, has started his own business.
H3, Rust implementation of HTTP3 protocol.
Quinn, asynchronous friendly QUIC implementation.
Tonic, is an asynchronous implementation of gRPC client and server.
Quilkin, described earlier, is a UDP proxy developed by Google Cloud in collaboration with Embark Studios, tailored for high-performance real-time multiplayer games.
RedisJSON, RedisJSON is a high-performance JSON document store that allows developers to build modern applications. It stores and processes JSON in memory to support response times of millions of operations per second at the sub-millisecond level. Native indexes, queries, and full-text searches for JSON documents allow developers to create secondary indexes to quickly query data.
Rust-rdkafka, a fully asynchronous Kafka client implementation.
Smoltcp, a stand-alone, event-driven TCP/IP stack designed for bare-metal real-time systems.
Rust-libp2p, libp2p network stack.

Eclipse zenoh

As the number of connected devices steadily increases, the industry is experiencing unprecedented heterogeneity in computing, storage, and communication capabilities, as well as new challenges in generating data and the scale of data that must be delivered and used.

In addition, performance, efficiency, and privacy concerns are driving a growing desire to keep data processing as close to the source as possible while facilitating access to remote applications. In other words, we are experiencing a mainstream architecture shift from a cloud-centric model (from cloud to cloud storage, processing, and collection of data) to an edge-centric model (storing and processing data where it makes the most sense for performance, energy efficiency, and security).

Zenoh, which provides zero-overhead Pub/Sub, Store/Query and computation. Integrate dynamic data, in-use data, and static data with computing. It deftly fuses traditional publish/subscribe with geographically dispersed storage, query, and computation while maintaining time and space efficiencies that far exceed those of any mainstream stack.

Zenoh is designed to meet the needs of applications that must handle dynamic data, static data, and computing in a scalable, efficient, and location-transparent data manner.

Zenon has now released a version code-named Aithusa that provides integration of the DDS Plugin and ROS2 for IoT, robotics and autonomous driving.

Web backend

Some people say that using Rust for Web development is a waste of time, but this view is based on the stereotype of “system-level languages.” Rust is outstanding in terms of performance, engineering architecture, and development efficiency, and it just needs a mature framework. In any case, Rust’s ecosystem in Web development is taking shape.

Poems: Bring Rust into the Web ecosystem

Poem is a Rust asynchronous Web framework developed by Chinese. The most exciting features of Poem are:

Feature rich, comprehensive.
It’s very simple to use and the documentation is great. See some examples here
OpenAPI specification generation support out of the box. This is a very important question because there is no popular Web framework in Rust that natively supports OpenAPI specification generation. OpenAPI support brings Rust into the Web ecosystem.
Support for middleware functionality (similar to express.js). Here’s an example
Use out of the box with AWS Lambda.
Compatible withTower ServiceandLayer.This allows you to do fun things here, like this oneexample.

Known open source projects that use Poem:

Delicate, a distributed task scheduling platform.
Databend, a data cloud service implemented by Rust.

Use the closed source project poem

Muse, NetEase’s internal art resource sharing platform of Thunder, is backed by Rust.
Hikvision’s HiK-ProConnect project is a front-end automation deployment platform based on AWS continuous integration.

SeaORM

SeaORM is an asynchronous dynamic ORM designed to be the Rust version of Active Record, built on SQLX and SeaQuery.

SeaQuery is a query generator that is the foundation of SeaORM for building dynamic SQL queries in Rust, using an ergonomic API to build expressions, queries, and schemas into abstract syntax trees (AST). MySQL, Postgres, and SQLite are all supported behind the same interface. It is similar to the Arel component of Rails’ ActiveRecord ORM framework.

SeaORM is currently under rapid development with release 0.5. SeaORM looks like a great development experience. For more information on SeaORM, see the Rust Ecology Observation | SeaORM: Making a Rust version of ActiveRecord.

Other interesting frameworks

Axum, tokio’s newly released Web framework, features macro-free, Tower middleware abstraction, and takes full advantage of the Tower ecosystem. The downside is that generics are used too much.
Perseus, for example, has added plugin system to support I18N, which is based on Fluent. Fluent has been used to translate rust’s official website. It is very convenient.

Big front end

Front-end infrastructure

Deno

Deno is a modern and secure TypeScritp and JavaScript runtime based on V8 and Rust implementations. Promises, Async /await, ES modules and asynchronous iterators are all first-class citizens in Deno.

To ensure that future developments in JavaScript will continue to apply to Deno and server-side JavaScript runtimes, Deno has joined the ECMA International Standards Organization responsible for the JavaScript standard (ECMA-262) and participated in the TC39 Working Group, Luca Casonato will be Deno’s main representative at TC39.

Deno has also partnered with GFX-RS to support WGPU for gPU-accelerated machine learning out of the box. Because of Deno’s modular architecture, the WebGPU implementation is one of the pluggable components.

Deno is currently in high development with version 1.17.3 released to date. Thirteen companies currently use Deno in their technology stack, including Cloudless, Appwrite, and The Lonero Foundation.

parcel && swc

Parcel is a Rust implemented Web application packaging tool for developers with varying experience. It takes advantage of multi-core processing to provide extremely fast speed and requires no configuration. It is implemented based on SWC. Parcel has also recently opened source a new CSS parsing, transformation, and compression tool called parcel- CSS.

SWC, short for Speedy Web Compiler, is an ultra-fast TypeScript/JavaScript Compiler written in Rust. Release updates are very active, with 1.2.179 just released three days ago.

Project Status:parcel / swc(Rust) vsesbuild (Go)

The SWC author and core Parcel contributor has now been hired by next.js; Esbuild is the author’s own side project;
SWC currently has at least four full-time developers.
SWC has more open source activity than EsBuild: SWC’s total PR numbers are over 1600, while Esbuild has over 200.
The issues of SWC and ESBuild are similar in number, but the issues of SWC are clearly classified and managed more carefully, and are linked to the release milestones.
SWC and ESBuild issues have very high frequency and timely response.
Parcel is active with over 2,000 PR and over 4,000 issues.

Trill company

At present, the business side of tiktok applet is also recruiting Rust developers to practice using Rust/C++ on some front-end infrastructure (such as compilers).

WebAssembly front-end framework

Yew

Yew is an advanced Rust framework designed to create multithreaded front-end Web applications using WebAssembly. Component-based, inspired by React and Elm, it is high-performance and supports interaction with JavaScript. It is currently under active development.

Sycamore

Sycamore is a responsive, virtual-dom-free front-end library, also based on Rust and WebAssembly. It features no JavaScript support because it is not needed.

Other frameworks

Percy, experimental Rust + WASM front-end framework
Seed, Rust front-end framework based on Elm architecture.
Sauron, a versatile Web framework and library for building client and/or server side Web applications, is very focused on simplicity. It is suitable for developing Web applications that use progressive rendering.
MoonZoon, a full-stack Rust framework under development, claims to have no JS/CSS/HTML, etc., and the development progress is slow.

In other areas

Audio and video

Audio processing

Creek, real-time disk stream IO for audio.
Symphonia, a library for pure Rust multimedia format demultiplexing, tag reading and audio decoding.
Cpal, pure Rust’s cross-platform audio I/O library.
Dasp, for digital audio signal processing.
Meadowlark aims to be a free and open source DAW (digital Audio Workstation) for Linux, Mac and Windows.

Video processing

Rsmpeg is a secure FFmpeg Rust binding library.
Gstreamer, the Rust binding library for Gstreamer. GStreamer is a pipeline-based multimedia framework, based on GObject and written in C. Pipelined design allows you to create many multimedia applications such as video editors, streaming media broadcasts, and media players.
Rav1e, the fastest and safest AV1 encoder.

Audio and video media services

Xiu, a simple and secure pure RUST (RTMP/HTTPFLV/HLS /relay) real-time media server.
Signal-calling-service, Selective Forwarding Units (SFU) based on WebRTC, which implements GOOGCC and transport-CC congestion control in the form of flow processing. This is open-source by Signal, a cross-platform encrypted messaging service.
Webrtc-rs, a pure Rust implementation of the WeBRTC stack, which overrides the Pion stack with Rust. The library is also under active development in 2021. Most of the features in the roadmap are already complete.

Rust and blockchain

Rust and smart contracts

Many blockchains either run smart contracts written in Rust or implement their smart contract runtime or language in Rust. They fall into several categories:

Based on WebAssembly smart contracts, Rust can be compiled into WASM, such as Elrond, Holochain, NEAR, Secret Network, Substrate. Most of these have the Rust SDK.
Tools that support compiling Rust to other VMS, for exampleNervos(RISC – V) andSolana(eBPF).
1. The Nervos contract is written using Rust and their Capsule library. In addition to being the only blockchain running RISC-V, Nervos is a rare smart contract blockchain that uses a UTXO model instead of an account model.
2. Solana runs a particularly odd VM: a user-space VM RBPF based on eBPF. Solana has put together an effective Rust->eBPF tool chain, which includes a branch of the Rust compiler that supports eBPF. Of course, since eBPF does not support loops, Rust here must be interesting.
People implementing smart contract languages in Rust, such as Solang (a Solidity to WASM compiler), Leo (a zero-knowledge language), and Move (a language for Diem). While many chains are moving to general-purpose VMS, and WASM in particular, there are two main reasons not to do so: a desire to be compatible with Ethereum EVM, and a proof based on zero knowledge. Move is a relatively rare case in that it is both its own language and its own VM, but there is no obvious reason to have a custom VM like a zero-knowledge language.

Some noteworthy projects

solang, is a Solidity compiler implemented with Rust but not for Ethereum EVM. Instead, it uses LLVM as the back end, which means it can potentially target the majorityDon’tThe blockchain that runs EVM. Currently including Substrate, Solana,ewasmandSawtooth.
Rust-umbral, is a proxy reencryption scheme in which Alice, the owner of the ciphertext, can designate a third party (the agent) to reencrypt the ciphertext to be decoded by Bob without disclosing the plaintext to the agent. It was developed by the NuCypher Project.
Noir, is a language and compiler for building zero-knowledge proofs. It is intended for use with multiple proofs generating backends, the first of which is for Barretenberg, as used by the Aztec Network.
MASQ, is a mesh overlay network, somewhat like TOR, but with crypto economic incentives to participate.
TDN, a trusted Distributed network, is a framework for building distributed applications that support P2P communication, multiple cross-communication blockchains, multi-layer blockchains, and multiple account models. It is built on Chamomile, a new P2P library.
bip32.This is BIP32Hierarchical deterministic Wallet and BIP39 mnemonic pure Rust, universal,no_stdFriendly implementation.
Jsonrpsee, an asynchronous implementation of JSON-RPC from Parity, which also created JsonRPC Crate.
Stateright is a model checker for implementing distributed systems in Rust. Unlike traditional model checker such as TLA+, Stateright is the Rust DSL that checks the Rust production implementation of the system. It includes examples of Paxos and other simple algorithms.
Arti, which is Rust’s official rewrite of Tor, was first announced in July. Tor is a key part of the distributed infrastructure, and this project enables Tor to be embedded in our applications.
Openmls, the Rust implementation of the Messaging Layer Security protocol, is an ongoing standard being developed by the IETF MLS Working Group. The e protocol is designed to address a problem still prevalent in secure messaging: while strong end-to-end encryption for two-party conversations is now possible, there are few good solutions for end-to-end encrypted group communications. MLS specifies “a key establishment protocol that provides efficient asynchronous group key establishment for groups ranging in size from 2 to thousands, with forward secrecy and post-disclosure security”.
Mina-rs is an implementation of MINA in Rust developed by ChainSafe. It was developed not only with the mobile environment in mind, but also with WASM in mind, indicating that we will be able to embed an entire node directly into the browser. Mina is a new blockchain network that uses zero-knowledge proofs to verify the state of the chain without having to access the entire blockchain, just a tiny (~ 22K) proof.
Arloader is a command line client for uploading files to Arweave. Files posted to Arweave will be stored permanently. This platform is typically used to store NFT information. Fees can be paid using Arweave native tokens or SOL.

Blockchain ecological information

In 2021, Near/Solana/ Dfinity/NeverOS will be the most popular blockchain public chain, with developer incentive programs and hackathons throughout the year.

More active concepts in 2021 are cross-chain, DeFI, NFT and Web3.

But blockchain is such a big ecosystem that a long article could be written in its own right. But thanks to sites like Rust in Blockchain ❤ Rib. rs, we’re keeping track of the Blockchain ecosystem on a monthly basis. If you are interested, you can look it up yourself.

Yuan universe

The metasverse is arguably the craziest concept of 2021, but its tech stack is very relevant to graphics, artificial intelligence, blockchain, VR/AR, IoT, and more. So is Rust ready on these fronts? Among them, graphics, artificial intelligence, blockchain, audio and video, IoT fields have been inventorized before, the specific status has been clear.

VR/AR, currently Rust ecology is also done, but not very rich:

Openxrs, which is a Rust binding to OpenXR. OpenXR is an application Programming Interface (API) for XR applications. It is an open source standard that developers can use OpenXR to build and deploy applications across devices.

XR refers to the continuum of real and virtual combined environments generated by computers through human-computer interaction, including technologies related to virtual reality (VR), augmented reality (AR) and mixed reality (MR). OpenXR is an interface between an application and an in-process or out-of-process “XR runtime system,” or simply “runtime.” The runtime can handle functions such as frame composition, peripheral management, and raw trace information.

Rust’s support for VR/AR may have started with OpenXR.

Makepad, is a VR, Web and native rendering UI framework and IDE, based on Rust and WebAssembly (WebGL) technologies. The writer is the founder of Cloud9 IDE. The project also contains a white paper that sets out its vision. The current development progress is not very frequent.

Information security

rustscan, is a modern high-performance port scanner, and provides a scripting engine to support running Python, Lua, Shell. Adaptive learning is supported. The more you use it, the smarter RustScan gets, not based on bloated machine learning, but on basic math.
feroxbuster, a high performance content discovery tool for penetration testing. Feroxbuster uses brute force combined with word lists to search for unlinked content in target directories, which is an attack. These resources may store sensitive information about Web applications and operating systems, such as source code, credentials, internal network addressing, and so on. This attack is also known as predictable resource location, file enumeration, directory enumeration, and resource enumeration.
Enarx, an organization led by Red Hat and other well-known companies to create application deployment systems for trusted execution environments.
sn0int, semi-automatic Advanced Open Source Intelligence (OSINT) framework and package manager for scanning target IP addresses, email, web sites and organizational information and gathering intelligence information from different message sources.
sniffglueMultithreaded network sniffer. Kpcyrd used tcpdump a lot, but he thought it would be nice if the output was friendlier, and wireshark was often bug-prone, as was tcpdump, so he implemented it in Rust.
ripasso, a password management tool.
Rustpad, a multithreaded successor to the classic Padbuster, is written in Rust. It uses the Padding Oracle vulnerability to decrypt any ciphertext or encrypt any plain text without knowing the encryption key!
Vaultwarden, an unofficial Bitwarden (password management) compatible server, formerly known as Bitwarden_RS.
Innernet, a private networking system that uses WireGuard (next-generation VPN technology) in the background.
Moonwalk, during Linux Exploitation, covers traces by leaving zero traces in the system log and file system timestamp. To assist red Team operations only.
CaptfEncoder, CaptfEncoder is a cross-platform network security tool suite, providing network security related coding conversion, classical cryptography, cryptography, public key encryption, aggregation query, and a variety of utilities. CaptfEncoder V3 uses Rust to develop executable programs that are smaller, faster, better performing, and more powerful. Its author is visually detected in Aliyun.

Scientific research and art

Nannou aims to let artists create their own art. Mindbuffer, a German firm, is based on Nannou and Koto to create physical art projects: using 486 steper motors, 86,000 leds and a five-channel particle synthesis engine, it creates colorful electronic art that can change shapes.
Glicol, a graph-oriented real-time music programming language. Glicol helps you make music using code. You can simply connect different nodes to form loops, written in Rust, which, thanks to WebAssembly, runs silkily in a browser.
3division-Rust, a physical science researcher, uses RUST to simulate three photons, constructing an exotic form of “molecular” light.
Varlociraptor implements a novel, unified approach to complete uncertainty perception for invoking genomic variation in arbitrary scenarios. This repository is a bioinformation processing repository mentioned in the article why Scientists Turn to Rust. It is still under active maintenance.
Eigenvalues, a library of eigenvalue solvers implemented by researchers at the Centre for Electronic Technology in the Netherlands, are described in the article applying Rust to Scientific Numerical Applications: Learning from Past experiences.

Rust occupational post

Occupational classification

Due to the security nature of Rust, there are many companies applying Rust in the financial field, so the largest distribution of Rust jobs in the world is blockchain and quantitative finance.

Basically, according to the current global Rust job recruitment, it can be divided into the following categories:

Blockchain/quantitative finance/banking
Infrastructure (cloud native platform development) : database/storage/data service/operating system/container/distributed system
Platform tools: Remote desktop/remote service products/SaaS/remote work products (such as Nexthink)
AI/machine learning/robotics
Client cross-platform component development
Security Engineer: Blockchain security/information security
Embedded engineer
Advertising services, for exampleAdinmo
Audio and video real-time communication engineer
Electric business platform
Software consulting

Specific Rust job listings can be found in Rust Weekly/Reddit R/Rust Channel/Rust Magazine/Rustcc forums, as well as on various job sites.

Part of Rust job information in China

Bytedance. Rust is used for bytedance’s internal infrastructure, Feishu and Douyin. There are many Rust job requirements.
Non-convex technology. Domestic enterprises to do quantitative, futures/stock market.
Sea star map. Rust is a subsidiary of Haizhi Group. Can be remotely.
Datan Technologies. A startup led by serial entrepreneur Dr. Pu Wang that uses Rust for distributed storage. Can be remotely.
Databend. A startup using Rust as a data cloud. Can be remotely.

There are a lot of other jobs out there, mostly blockchain positions, which I won’t list here.

Complete global inventory of Remote Rust jobs

Please note that some of the jobs claimed to be completely remote are actually only considered for US/Canada and sometimes even EU residents, depending on your luck and communication skills!

RedHat, Rust position, remote. You can find out more at Reddit @sheepdog69.
Tangram, a developer of machine-learning tools, can send email inquiries about working remotely, but the position is only open to U.S. / Canadian/European candidates.
The Materialize real-time Streaming database (described earlier) has remote positions, which require email inquiries.
Toyotaconnected, currently only allowed for remote travel in 12 U.S. states, is a member of the Rust Foundation. They use Rust for machine learning jobs and devices. A lot of interoperability in vendor C and CPP code and a lot of cool, interesting issues that we’re solving inside Toyota and Lexus cars as 5G becomes more and more popular.
Era Software, Remote (US/Canada/Europe), competes with Elasticsearch. All database engineering jobs are for Rust.
Qovery, Remote (EU), Qovery is a platform that gives any developer the super ability to deploy their applications to the cloud in seconds.
Estuary, remote Rust developers to develop Flow, our real-time data platform, will need email inquiries.
Infinyon, Remote (US), for building a reliable and scalable infrastructure for real-time data streaming, with Fluvio and Infinyon Cloud products.
Ockam, Ockam is building open source, end-to-end encryption and mutual verification communication protocols and libraries that work in resource-constrained, intermittently connected iot devices and connected machines.
1passwordRemote (,Canada, the US and the UK), password management software.
IOHK, remote, blockchain, for details please click the link to apply for a job.

The above list is only a part of the visible network, for domestic partners, these positions may not apply. For foreign partners, may be a blessing.

The prevalence of Rust language education

Published books at home and abroad

A list of books published at home and abroad from 2018 to 2022.

domestic

The Simple Truth of Rust
The Rust Way of Programming
The Authoritative Guide to Rust
Rust Programming: Getting Started, Practicing, and Advancing

Abroad:

Rust in Action
Programming Rust, 2nd Edition
Rust for Rustaceans
Refactoring to Rust
Black Hat Rust
Hands-on Rust
Zero To Production In Rust

These books are not all, there are many foreign books not listed.

It can be seen that the number of Rust books is increasing in foreign countries and also in China.

Popularization of higher education

domestic

As far as I know, Rust is only applied in the OS courses of Tsinghua University in China. Also see: operating system written in Rust | tsinghua rCore OS tutorial.

Abroad:

Warsaw University, Poland, has decided to start Rust for second-year students.
Professor Lin Zhong of Yale University has published “CPSC 429A, Principles of Computer System Design” and “CPSC 425B, Mobile and Embedded Systems” which support Rust. But the course is not open.

Reddit discussion: What would your dream Rust class look like?

A teaching assistant at Warsaw University in Poland started the discussion on Reddit and has been teaching memory management and programming in C (first year) and concurrent and parallel programming in Java and C (second year). Now the school has decided to start Rust for second-year students, and he has been entrusted with preparing the lessons and teaching them. He wants to ask Rust developers for advice. What would your dream Rust University curriculum look like?

His current teaching plan goes something like this:

Use the official The Book as a textbook. As a teacher, he will condense the knowledge in the book into PPT for teaching.
In the process of learning grammar, there are also some best practices of Rust ecology.
After learning the book, I will focus on asynchrony.
Set up five small tasks of different levels for students to complete, each task has ten days to complete.

See the Reddit post for more details. In the comments, someone offered some advice:

An undergraduate using Rust to complete the Reinforcement library: github.com/ZuseZ4/Rust… Rust is used in the teaching of machine learning because it is easier to learn machine learning using Python. (It is also reasonable to say that when learning, pay attention to the learning goal, the learning goal of students is to learn the field of machine learning, not Rust).
A friend said that students should be taught how to solve problems in college. For example, by learning the realization of multi-threaded life game, to learn to solve the problem of multi-threaded concurrency.

What do you think about that?

conclusion

It is very tiring to conduct ecological research on Rust, because Rust, as a truly universal language, has too much ecological information and involves many fields. But I also insisted on finishing this report because I really like The Rust community, which I see as a community full of hope and vitality. I hope you like Rust as much as I do.