Unlike most "modern programming languages", one of Rust's highlights is that it can be directly compiled into machine code without needing an intermediate "runtime". However, when Rust is used in scenarios such as browsers, cloud-native environments, and edge devices, running machine code directly is not allowed. In this case, we need a runtime to run Rust code. In practice, WebAssembly has become one of the preferred runtimes for Rust. The Rust compiler has also added a target for the Wasm platform. However, many common Rust crates still have difficulties running in WebAssembly. In this talk, I will introduce the current status, limitations, solutions and future directions of the Rust WebAssembly compiler and standard/common libraries to provide advice for developers who want to develop Rust-Wasm applications.

The problem of slow compilation efficiency is a challenge that Rust language must face as it gradually moves towards large-scale development. Nowadays, the optimization of single-threaded compilation efficiency in Rust has reached a bottleneck, and parallel compilation has become the key technology to break through this bottleneck. As a core developer of Rust's parallel compilation feature, the speaker will introduce to you the series of challenges and breakthroughs faced by this feature.

For a Rust RPC framework, code generation based on IDL is to make it more convenient for users to use the framework. The quality of generated code and its surrounding capabilities will have a very direct impact on the user's development experience. Therefore, we developed a framework like Pilota to generate good code for users. Also, because of some special requirements within ByteDance, our code generation framework has brought us great challenges. This sharing session will introduce the design principles of Pilota and some challenges faced. 1. What problem does Pilota solve? 2. Detailed explanation of Pilota's design structure 3. Type System in Pilota 4. Experience optimization done by Pilota when facing large IDLs

Rspack is a high-performance build engine based on Rust, which can interact with the Webpack ecosystem and provide better build performance. When dealing with monolithic applications with complex build configurations, Rspack can provide 5-10 times faster compilation performance. This time we will share: 1. How to choose native technology for front-end toolchain 2. Performance optimization: a. Transforming existing single-threaded algorithms into multi-threaded ones to improve parallel performance b. How to optimize core library lock contention to improve application performance. c. How to use profile tools to troubleshoot memory and IO bottlenecks and optimize application performance. d. By using the above methods, we doubled our initial performance improvement. 3. How to improve rust and js interop and optimize tool plugin capabilities

A complete expression execution framework covering SQL parsing, type system construction, and efficient vectorized evaluation. It deeply analyzes the unique advantages of Rust in implementing efficient SQL parsers and building complex type systems. At the same time, it will also demonstrate how to use Rust's type system to implement a high-performance vectorized evaluation system, helping Databend database provide faster and more powerful solutions in practice.

Rust is a language that promises memory safety and concurrency safety, so ensuring the security and reliability of Rust libraries is an extremely important issue. Although Rust code effectively guarantees memory safety, this does not mean that bugs will not occur in Rust language programs. For example, the unsafe mechanism provided by Rust for low-level system programming may still introduce security risks such as dangling pointers. Currently, a small number of studies on Rust security risks have already summarized some code patterns that may cause memory problems artificially, but there is no systematic summary of common bug patterns that appear in real Rust projects. Therefore, we conducted empirical research using code mining technology to summarize common code bug fixing patterns from real-world Rust language program projects and explore bugs related to Rust language features. At the same time, in order to further ensure the safety of Rust libraries, we propose a method based on the existing Rust ecosystem to generate fuzzy test targets. This method uses MIR parsing technology to find API calls and dependencies between APIs in projects within the ecosystem where the library under test is located, thereby extracting API sequences for testing purposes and generating fuzzy test targets for Rust libraries accordingly. To this end, we have implemented a tool for generating fuzzy test targets which utilizes AFL for fuzz testing. This tool proposes a new way of generating fuzzy test targets for rust which greatly reduces manual generation costs while being able to generate API call sequences more consistent with human programming habits making it easier to detect bugs commonly encountered during actual development processes thus having better practicality overall.