Day 1: April 20


Check In

8:50 9:00

Opening & Welcome

9:00 9:10

Opening talk: Rust in PingCAP

9:10 9:20

Opening talk: Why RustCon Asia

9:20 9:30

Opening talk: Rust in Baidu X-Lab

09:35 10:05

Making Rust Delightful

Nick Cameron
Nick Cameron

Rust strives to be an ergonomic language: easy to read, easy to write, and easy to maintain. We want it to be a language which delights! But what does that mean? How do the language and library designers decide what makes a feature ergonomic? And how do we consider the trade-offs between ergonomics and other design pressures such as safety and performance?

I’ll cover Rust’s design philosophy, some case studies on ergonomics from the language, libraries, and tools, and talk about how design decisions are made by the language team and others. I’ll talk about issues such as ‘explicit vs implicit’, syntactic sugar, and consistency.

10:10 10:40

Linux From Scratch in Rust

Mingshen Sun
Mingshen Sun
Rust’s memory-safety and zero-abstraction makes it the best candidate for system programming. To provide a safe execution environment, we build a Linux distribution from scratch in Rust including a building system, user-space utilities, and a simple package management system. In this talk, we mainly focus on our user-space toolbox, which is a collection of core system utilities. We will discuss some design challenges and problems we encountered in building the toolbox, e.g., handling standard I/O, dynamic dispatching vs static generic type, testing and coverage issues, etc.
10:40 10:55


10:55 11:10

Rust for competitive programming

Competitive programming requires you to solve problems efficiently and correctly in a very short time. Since there is not a single library that designed for competitive programming, contenders often have to implement non-trivial data-structures and algorithms from scratch which tedious and error-prone. This talk is about why Rust is a good fit for making libraries for competitive programming and how.
11:15 11:30

Implementing a secp256k1 library in pure Rust

Wei Tang
Wei Tang
This talk discusses my experience in implementing libsecp256k1, a pure Rust library that provides full secp256k1 signing and verification functionality, and runs in no_std environments.
11:35 12:05

How Rust taught me to think about systems

Ravi Shankar
Ravi Shankar
All Rustaceans know that Rust’s borrow checker is merciless to newcomers. This talk covers the pain points encountered by me, back when I was a newcomer to Rust (and systems, in general). We’ll see a variety of situations which are totally normal in a number of high-level languages but not in Rust, how the same code differed in Rust, how the errors made sense after a while, and how that changed me to think about approaching problems from there on. If you’re looking for motivation to get into Rust, or if it made you angry or scared you away at some point, then this talk is for you!
13:00 13:30

Futures in TiKV

Qu Peng
Qu Peng
TiKV is a high performance distributed K-V storage engine. Many components like readpool, coprocessor are based on futures. And some other components like threaded raftstore are designed in task-executor style, which is inspired by futures-rs. In this short talk I want to share with you how TiKV uses futures and then implements a similar system.
13:35 14:05

Implementing a p2p network framework



I will probably talk about the development of this library, the problems encountered, and so on, and explain the implementation of each small library.

This library is a small supplement to the Rust network ecosystem. I hope that more people will participate in the Rust ecosystem. Such a good language should have a better ecological support.

14:10 14:40

Stackful coroutine based rust async story

Xudong Huang
Xudong Huang

While the official future based asynchronous system is under way of building and maturing, I’d like to talk about another asynchronous story that based on stackful generators and coroutines.

I’m the author of May( I could talk the designs and implementations of it, give some fundamental concept about generator and coroutine, the overall structure of coroutine scheduling, the sub IO system, the sub sync preemptive system, the cancellation mechanism, and and compare it with current future based systems

14:40 14:55


14:55 15:25

Improving web app with Rust and WASM

Ilya Baryshnikov
Ilya Baryshnikov
WebAssembly is a new standard which can be used to speed up heavy computations in the browser. But what is a “heavy computation”? How it may affect your users and your business? I will show several examples of heavy computations in React + three.js app. We will compare performance of JS and Rust. Then I will share our story of introducing Rust and WebAssembly to the app. How to write the code, how to build and publish npm module, and how to finally load it with webpack. We will discuss how wasm-bindgen library can help you to communicate with the JS world and reduce the boilerplate. In the end we’ll talk about quality control tools and tests.
15:30 16:00

Cargo meets Autotools

Yiming Jing
Yiming Jing

Since 1.10, rustc can generate a dynamic library that is intended to be used from C or C FFI, as long as the cdylib crate type is specified in Cargo.toml. While the cargo install command makes it a breeze to distribute executables (e.g. ripgrep), it does NOT work with cdylib dynamic libraries.

Back in 2018 we had struggled a long way to get a working build infrastructure, just to build and distribute our dynamic library written in Rust. Eventually, we made autotools work happily together with the rust toolchain. Now a user can just download our source tarball, uncompress, and run ./configure && make && make install, just like old times. In this talk we’d like to share our story and hopefully this will be useful for the community.

16:05 16:35

Re:Zero - writing a custom derive

Xidorn Quan
Xidorn Quan
Custom derive code can be challenging to read and write for developers who are not familiar with it, however it is a very powerful tool which may empower people to write less code while have more things done. It has been widely used in Servo’s style system. This talk will take a brief look at how custom derive is used in Servo’s style system, and describe how a custom derive can be developed from scratch.
16:40 17:10

Distributed Actor System in Rust

Zimon Dai
Zimon Dai
We designed our distributed actor system in Rust. This kind of system involves many problems as Rust is strong-typed with neither a VM nor reflection. This lecture shares our approach to create such a system. Also shares how to erase type information to do networking and recover the type for messaging in Rust. And other unique design patterns including how to dynamically create new actor types and inject into the system (using proc macros).


Day 2: April 21


Check In

08:40 09:10

Be Fearless Using Rust in Production


We need a high performance and stability image rendering web server to handle creative real-time generation for Taobao Wireless focus picture.

The service requires algorithms to select products, copywriting and creative templates according to different users, and then generate creative to be displayed in real-time. At the beginning of our development with Node, but unable to meet performance requirements soon.

Our team replace Node version server with Rust version since 2016, and got greatly increase of RT and QPS. This server is running over two years, and have stood the test of two “Double 11”.

This topic will share our experience on how we use Rust in production.

09:15 09:45

Rust at Bilibili

WaySLOG & hawkingrei WaySLOG & hawkingrei
WaySLOG & hawkingrei

Bilibili is an online video barrage website. We are happy to try new technology, and Rust is also the language I am optimistic about. Today we will introduce to you three of our components that use Rust:

  • Caching proxy component
  • Image processing component
  • Compile the remote cache component

I would like to introduce you to some of the problems we encountered when using Rust and a little experience, I hope to help everyone.

09:50 10:05

How to learn Rust efficiently

What is the real reason for the “Rust learning curve is high”?

  • What is efficient learning?
  • What are the common pitfalls in learning Rust?
  • Learn from Rust’s ten recommendations.
10:05 10:20


10:20 10:50

Search Engine in production with Rust

Xiaoguang Sun
Xiaoguang Sun
This talk will review the design choices and the lessons we learned while we develop a real-world Search Engine with Rust. The audiences could potentially avoid similar mistakes we made and are more willing to use Rust in production.
10:55 11:25

Closing Project Update



Day 3: April 22

09:00 12:00

Introduction to IoT using Blynk, Rust and your Smartphone - Room A

Rahul Thakoor
Rahul Thakoor

Do you want to leverage your smartphone’s sensors and actuators? Do you want to learn the basics of IoT, and bridge the virtual and physical world? And do you want to do it all using Rust?!

In this workshop, you can get a taste of the embedded world without breaking the bank. We are going to use Blynk, which is a free smartphone app providing drag-and-drop widgets for your IoT projects. You will need a smartphone (iOS or Android) and a laptop running Linux, macOS or Windows.

We will introduce the basics of IoT. You will configure virtual LEDs and buttons, collect sensor data like GPS stream or Accelerometer or send events and data to your phone. By the end, you will be able to use your skills learned prototyping to make more creative and fun projects and blaze your own trail. You will also get a better understanding of IoT projects and be inspired to get started with embedded Rust on microcontrollers or other hardware.

09:00 12:00

Rust at Cryptape - Room B

Zhiwei Ning
Zhiwei Ning

At this workshop you will learn:

  • How Clippy works
  • How to contribute to Clippy
  • Two useful tools inspired by Clippy
  • Relationship between Blockchain fork and Expression Problem
  • How to slove Expression Problem in Rust

All level are welcomed!

If you familiar with Blockchain, we can discuss more about it after above contents.

10:00 18:00

RustBridge - Room C

Olivia Hugger
Olivia Hugger
RustBridge is an all-day workshop focused on getting underrepresented people with a background in another programming language to learn Rust and join the community. In this workshop we’ll get you up and running with a Rust development environment, introduce you to Rust syntax and programming concepts, and work together to build a small website that you can personalize, extend, and share!
13:00 17:00

WebAssembly with wasm-bindgen - Room A

Ilya Baryshnikov
Ilya Baryshnikov

Advanced details about Rust and WebAssembly.

We will discuss two major topics: moving computations to wasm and DOM manipulations.

At this workshop you will learn:

  • how to compile Rust to wasm using rustc
  • why communications between Rust and JS could be hard
  • how wasm-bindgen simplifies development
  • how to build module with wasm-pack
  • how to use wasm from various environments: webpack, node.js, plain html (without bundlers)
  • any additional topics, suggested by attendees

After this workshop you will be ready to start using Rust in your web app. If you already familiar with Rust and wasm-bindgen, we can still try to discuss more advanced problems and how to deal with pain points.

13:00 17:00

Rapid Development of RESTful microservices using actix-web and diesel - Room B

Taking the TodoList as an example, we will use Actix-web and Diesel to implement a microservice interface service.

  • Introduction to Actix/Actix-web and Diesel.
  • How to organize the code using Actix-web.
  • Preliminary practice.
  • How to use abstract tool code refactoring such as generics, traits, etc. And how to use macros to Don’t Repeat Yourself.
  • How to package the service into a 10M Docker image for deployment.

Day 4: April 23

09:00 12:00

Build a Secure and Trusted Framework in Rust - Room A

Yu Ding & Mingshen Sun Yu Ding & Mingshen Sun
Yu Ding & Mingshen Sun

This talk intends to be a long talk (~4 hrs) introducing the Rust TEE ecosystem.

Rust SGX SDK has become the most popular SGX development environment. Previous talks at RustFest, QConSF and QConBJ are all brief talks within 30 minutes and limited Q&As. This time I’d like to present its details and current ecosystems. In addition, we’ll include the Rust-trustzone part.

The talk would guide the audience to play Rust on two TEEs: SGX and Trustzone. In the beginning, we’ll talk about the trusted computing theory and hardware-assisted trust execution engines. Then we assist the audience with hands-on experiments on Rust+SGX and Rust+Trustzone platforms. At last, we’ll discuss about the internals and ecosystems.

09:00 12:00

Thinking In Rust - Room B

Nick Cameron
Nick Cameron

Learning a new programming language is hard. Even after mastering the syntax and type system, learning the libraries and techniques can take years. If you’ve read or written Rust and want to improve, this talk will give you a turbo boost! This will be a very practical tutorial, aimed at taking your Rust programming to the next level. We’ll teach some core Rust design principles by covering a few key topics in depth.

The tutorial will start with programming ‘in the small’: we’ll explore some key library types (Option, Result, and Iterator) and cover practical error handling. Putting these together we’ll see how to structure your control flow to write clear, succinct programs. We’ll then cover some larger-scale design issues - using ownership as a primary architectural principle, and abstraction using traits.

You’ll learn how to be more productive in Rust by writing clean and idiomatic code. You’ll learn to work with the language rather than fighting against it.

09:00 10:30

Learning Rust FFI - Room C


This workshop teaches developers about compiling rust FFI - from a beginner to a master. This course can help you to bindgen any C/C++ library, and package C/C++ to a certain extent.

  • learn about bindgen,, initially work with libwebp ffi
  • implement libwebp wrapper, and turn png into libwebp
  • implement in-library libwebp version, refer libwebp without libwebp

This course requires you to have some basic knowledge about Rust language(no knowledge base is also okay), no requirement for c/c++. In this course, you can use Linux/Mac OS in order to do some experiment, for those using Windows you should set a virtual machine first.

10:30 12:00

Building a simple RESP parser - Room C


This workshop opens to those developers who are experienced in Rust, especially for those who were once a beginner, then gave up and finally became a beginner again!

We will focus on redis’ RESP protocol, and work together to optimize this parser

  • walking through the definition of redis RESP protocol(
  • implement simple parser with single pass backtracking
  • use simd to accelerate specific environment of parser
  • use tools like cargo flamegraph/dtrace/perf to generate flame graph, also to generate diff flame graph
13:00 17:00

Integrate rust-prometheus into your application - Room A

Wish (施闻轩) & Shirly (吴雪莲) Wish (施闻轩) & Shirly (吴雪莲)
Wish (施闻轩) & Shirly (吴雪莲)
Knowing what is happening and what was happened to your application is usually very difficult without any monitoring facilities. This workshop will teach you how to use rust-prometheus to continuously collect metrics for your application, using a simple web server written in Rust as an example. It includes

  1. Introduction to the Prometheus and the rust-prometheus client
  2. Using rust-prometheus to collect different kind of metrics
  3. Exposing collected metrics to Prometheus and using Grafana to visualize
  4. The performance impact of the metrics and different ways to greatly improve performance
13:00 17:00

Build a Decentralized app on Blockstack Chain V2 - Room B

Su Bo
Su Bo

Blockstack is a full-stack decentralized computing network that enables a new generation of applications where developers and users can interact fairly and securely while curing the ills of centralized Internet design. Blockstack builds protocols and developer tools designed to enable a fair and open Internet that returns digital rights to developers and consumers. Led by some of the world’s foremost experts on distributed systems, Blockstack allows users to own their own data that they can take with them from app to app in the ecosystem, along with their Blockstack ID that eliminates the need for password-based logins. The end result is privacy, security, and freedom.

Stacks blockchain v2 is planned for late 2019 and will introduce two big changes/features.

  • A new consensus algorithm
  • A full smart contract system

The proposed consensus system aims to combine the best of classic distributed systems consensus algorithms and proof-of-work. The aim is an open membership system (unlike classic distributed consensus algorithms) but wants better scalability and throughput than proof-of-work blockchains like Bitcoin.

Stacks blockchain v2 is being written in Rust. You can follow the development here. The new consensus algorithm and the new smart contract system are proposed as Stacks Improvement Proposals (SIPs) and can be found as SIP-001 38 and SIP-002 27.

This workshop includes the following: * Setup Blockstack Chain V2 with Rust * Build a Decentralized app * Run your Dapp

13:00 17:00

Building a blockchain using Rust with Parity Substrate - Room C

Gautam Dhameja
Gautam Dhameja

Rust + Blockchain: What can be more cutting edge than that combo? In this workshop learn to build your own blockchain using Rust with the Parity Substrate framework. The workshop helps Rust developers in getting started on the Substrate framework. Substrate allows you to build custom, highly efficient and modular blockchains using the Rust programming language.

The workshop includes the following:

  • Introduction to the Substrate framework
  • Getting started with blockchain development using Substrate
  • Building a sample Substrate runtime