作者 | 张汉东 责编 | 欧阳姝黎
Rust 语言是一种通用的系统编程语言，没有GC以确保内存安全、并发安全和高性能而闻名。自2008年以来 Graydon Hoare 2009年获得私人研发 Mozilla 赞助于2010年首次发布 0.1.0 版本，用于Servo 发动机研发，于 2015年5月15号发布 1.0 版本。
自发布以来，已经结束了 2021 今天，经过六年的发展，Rust 稳步上升，逐渐成熟稳定。
至 2016 年开始，结束 2021年，Rust 连续五年成为 StackOverflow 语言列表中最受欢迎的语言[1]。
2021年 2 月 9 号，，成为白金成员，致力于全球推广和发展 Rust 语言。
那 Rust 语言的魅力是什么，能让开发者和巨头如此感兴趣？
本文从 Rust 语言本身的特点 和 Rust 行业应用库存两个方面的社区研究试图回答这个问题，希望通过这些简单但关键的数据 Rust 在当前各大领域的应用中，有一个全面直观的印象供思选择 Rust 公司参考。
注：本文所列数据均来自互联网披露内容。
编程语言设计可调和的愿望之间，编程语言设计长期存在矛盾。
安全 ( safe )。我们希望强大的系统能统来静态地消除很多错误。我们需要自动内存管理。我们想要数据包装， 这样我们就可以对私有变量执行不变的对象的表示形式，并确保它们将不会被不受信任的代码破坏。
控制 (control )。至少对于 Web浏览器、操作系统或游戏引擎 系统编程 (system programming) 程序，约束它们性能或资源是一个重要的问题，我们想了解数据的字节级表示。我们想用底层语言 (low-level programming) 优化我们程序的时间和空间。我们希望在必要时使用它 裸机 。
然而，按照传统观点，鱼和熊掌不能兼得。Java 这种语言极大地保证了我们的安全，但代价是牺牲对底层的控制。因此，对于许多系统编程应用程序来说，唯一现实的选择就是使用一个像 C 或 C 语言控制资源管理提供细粒度。然而，获得这种控制成本很高。例如，微软最近报告说，他们修复了它 70％ 安全漏洞归因于内存安全违规行为 33[2]，都是能被强型系统排除的问题。同样，Mozilla 报告指出，绝大多数关键点 他们在Firefox发现的错误是与内存相关的16 [3]。
若能以某种方式两全其美： 在编程安全系统的同时控制底层并不漂亮。Rust 语言应运而生。
这样介绍官网 Rust : 一门给每个人 构建可靠高效的软件能力语言。
Rust 语言有三个优点值得关注：
高性能。Rust 速度惊人且内存利用率极高。由于没有运行时和垃圾回收，它能够胜任对性能要求特别高的服务，可以在嵌入式设备上运行，还能轻松和其他语言集成。
可靠性。Rust 丰富的系统类型和所有权模型保证了内存安全和线程安全，使您能够在编译期间消除各种错误。
生产力。Rust 文档优秀，编译友好，提示信息清晰， 还集成了一流的工具-包管理器和施工工具， 多编辑器支持智能自动补充和类型检验， 以及自动格式化代码等。
Rust 如有必要，足够的底层可以像 C 为了达到最高以实现最高性能。
抽象层次越高，内存管理越方便，可用库越丰富，Rust 程序代码越多，做的事情越多，但如果不控制，可能会导致程序扩展。
然而，Rust 程序优化也很好，有时比较 C 语言更好，C 语言适用于在字节和指针的级别上编写最小代码 Rust 它具有强大的功能，可以有效地将多个函数甚至整个库结合在一起。
但是，最大的潜力是可以无畏（fearless）大多数并行化 Rust 代码，即使等价 C 并行化代码的风险很高。在这方面，Rust 语言是比 C 语言更成熟。
Rust 语言还支持高并发零成本的异步编程，Rust 语言应该是第一个支持异步编程的系统语言。
用 Rust 编写的程序的运行速度和内存使用应与使用相同 C 编程类似，但这两种语言的整体编程风格不同，很难总结其性能。
总的来说：
抽象是一把双刃剑。Rust 语言抽象程度比 C 语言更高，抽象会隐藏一些不那么优化的代码，这意味着默认实现 Rust 代码性能不是最好的。所以，你的 Rust 代码必须经过优化才能媲美 C 的性能。Unsafe Rust 是高性能出口。
Rust 默认线程安全，消除数据竞争，使多线程并发编程更具实用价值。
Rust 在某些方面确实比较 C 快。理论上，C 语言什么都能做。但在实践中，C 抽象能力相对较低，不那么现代，开发效率相对较低。只要开发者有无限的时间和精力， C 在这些方面比较语言 Rust 更快。
因为 C 语言足以代表高性能。让我们分别谈谈 C 和 Rust 异同。假如你熟悉 C/Cpp，也可以根据这个比较进行评估 Cpp 和 Rust。
Rust 和 C 直接抽象硬件可以看作是一种「可移植汇编程序」。
Rust 和 C 它可以控制数据结构的内存布局、整数大小、堆内存分配、指针间接搜索等，一般可以翻译成可理解的机器代码，编译器很少插入 "魔法"。
即便 Rust 比 C 具有迭代器、特性等更高层次的结构（trait）和智能指针，它们也被设计成可预测的优化为简单的机器代码(也称为 "零成本抽象"）。
Rust内存布局的类型非常简单，例如，可生长的字符串String 和 Vec<T> 正好是{byte*, capacity, length}。Rust没有任何像 Cpp里的 移动 或 复制结构函数 这样的概念，所以对象的传递保证不会比传递指针或 memcpy 更复杂。
Rust 借用检查只是编译器对代码中引用的静态分析。生命周期（lifetime）信息早就在 中间语言（MIR） 生成前完全抽离。
Rust 基于返回值的错误处理不是传统的异常处理。但你也可以使用它 恐慌（Panic）来处理像 Cpp 中间的异常行为。编译时可以禁用（panic = abort），但即便如此，Rust 也不喜欢 与 Cpp异常 或 longjmp 混在一起。
Rust与LLVM整合良好，支持链接时间优化，包括ThinLTO，甚至是跨越C/C /Rust语言边界内联。还有配置优化（Profile-guided Optimization，PGO）的支持。尽管 rustc 比 clang 生成的LLVM IR它更长，但优化器仍然可以很好地处理它。
C 语言用 GCC 编译比用 LLVM 更快，现在 Rust 也有人在开发社区 GCC 的 Rust 前端。
理论上，因为 Rust 有比C 比较更严格的不可变和别名规则 C 语言有更好的性能优化，但实际上并没有起到这样的作用。LLVM中，超越 C语言优化是一项正在进行的工作，所以Rust它的潜力还没有达到。
Rust 代码足够底层和可预测，可以手动调整其优化的汇编代码。
Rust 支持 SIMD ，对内联和调用约定有很好的控制。
Rust 和 C 语言足够相似，C 一些语言分析工具通常可用于 Rust 。
一般来说，如果性能绝对关键，最后一点性能需要手动优化压榨，那么优化 Rus t 与 优化 C 语言没有什么不同。
但是在一些比较底层的特性，Rust 没有特别好的替代方法。
goto。Rust 中没有提供goto，但是你可以使用循环 break 替换标签。C 一般用于语言 goto 但是 Rust 由于具有确定性分析功能，因此无需 goto。然而有一个 非标准的 goto 扩展对性能优化更有用。
栈内存分配alloca和C99可变长度数组可以节省内存空间，减少内存分次数。但即使是这些 C 语言也有争议，所以Rust远离它们。
如果没有经过手工优化，Rust 因为其抽象表达也会有一些开销。
Rust缺乏隐式类型转换和只用usize的索引，这导致开发者只能使用这种类型，哪怕只需要更小的数据类型。64位平台上用usize做索引更容易优化，而不需要担心未定义行为，但多余的bit位可能会给寄存器和内存带来更大的压力。而在 C 中，你可以选择 32位类型。
Rust 中的字符串，总是会携带指针和长度。但是很多 C 代码中的函数只接收指针而不管大小。
像 for i in 0...len {arr[i]} 这样的迭代，性能取决于 LLVM 优化器能否证明长度匹配。有时候，它不能，并且边界检查也会抑制自动矢量化。
C 语言比较自由，对于内存有很多“聪明”的使用技巧，但在 Rust 里就没这么自由了。但Rust仍然给了内存分配很多控制权，并且可以做一些基本的事情，比如内存池、将多个分配合并为一个、预分配空间等等。
在不熟悉 Rust 借用检查的情况下，可能会用 Clone 来逃避使用引用。
Rust 的标准库中 I/O 是不带缓存的，所以需要使用 BufWriter 来包装。这就是为什么有些人说 Rust 写的代码还不如 Python 快的原因，因为 99% 的时间都用在 I/O上了。
每个操作系统都有一些内置的标准C库，其中有大约30MB的代码。C 语言的执行文件，可以“免费”使用这些库。
一个小的 "Hello World " 级 C 可执行文件实际上不能打印任何东西，它只调用操作系统提供的printf。
而 Rust 则不可以，Rust可执行文件会捆绑自己的标准库（300KB或更多）。幸运的是，这只是一次性的开销，可以减少。
对于嵌入式开发，可以关闭标准库，使用 "no-std"，Rust将生成 "裸 "代码。
在每个函数的基础上，Rust代码的大小与C差不多，但有一个 "泛型膨胀 "的问题。泛型函数为它们所使用的每一种类型都有优化的版本，所以有可能出现同一个函数有8个版本的情况，cargo-bloat[4] 库有助于发现这些问题。
在Rust中使用依赖关系是非常容易的。与 JS/npm 类似，现在推荐使用小型且单用途的包，但它们确实在不断增加。cargo-tree 命令对于删减它们非常有用。
为了隐藏实现细节，C 库经常返回不透明的数据结构指针，并确保结构的每个实例只有一个副本。它会消耗堆分配和指针间接寻址的成本。Rust 内置的隐私、单一所有权规则和编码惯例允许库暴露其对象，而不需要间接性，这样，调用者可以决定将其放入堆（heap）上还是栈（stack）中。可以主动或彻底地优化栈上的对象。
缺省情况下，Rust 可以将来自标准库、依赖项和其他编译单元的函数内联。
Rust 会对结构体字段进行重排，以优化内存布局。
字符串携带大小信息，使得长度检查速度很快。并允许就地生成子串。
与 C++ 模板类似，Rust 中泛型函数会单态化，生成不同类型的副本，因此像 sort 这样的函数和 HashMap 这样的容器总是针对相应的类型进行优化。对于 C 语言，则必须在修改宏或者处理void*和运行时变量大小的效率较低的函数之间做出选择。
Rust的迭代器可以组合成链状，作为一个单元一起被优化。因此，你可以调用it.buy().use().break().change().mail().upgrade()，而不是对同一个缓存区多次写入的一系列调用。
同样，通过 Read 和 Write 接口，接收一些未缓存的流数据，在流中执行 CRC 校验，然后将其转码、压缩，再写入网络中，所有这些都可以在一次调用中完成。虽然 C 语言中应该也可以做到，但它没有泛型和特质（trait），将很难做到。
Rust 标准库中内置高质量的容器和优化过的数据结构，比 C 使用起来更方便。
Rust的 serde 是世界上最快的JSON解析器之一，使用体验非常棒。
主要是两点：
Rust 消除数据竞争，天生线程安全，解放多线程生产力，是 Rust 明显比 C / Cpp 等语言优越的地方。
Rust 语言支持异步高并发编程。
Rust 支持 安全的编译期计算。
即使是在第三方库中，Rust 也会强制实现所有代码和数据的线程安全，哪怕那些代码的作者没有注意线程安全。一切都遵循一个特定的线程安全保证，或者不允许跨线程使用。当你编写的代码不符合线程安全时，编译器会准确地指出不安全之处。
Rust 生态中已经有了很多库，如数据并行、线程池、队列、任务、无锁数据结构等。有了这类组件的帮助，再加上类型系统强大的安全网，完全可以很轻松地实现并发/并行化 Rust 程序。有些情况下，用 par_iter 代替 iter 是可以的，只要能够进行编译，就可以正常工作！这并不总是线性加速（ 阿姆达尔定律（Amdahl's law）很残酷），但往往是相对较少的工作就能加速 2~3 倍。
延伸：阿姆达尔定律，一个计算机科学界的经验法则，因 Gene Amdahl 而得名。它代表了处理器并行计算之后效率提升的能力。
在记录线程安全方面，Rust 和 C 有一个有趣的不同。
Rust 有一个术语表用于描述线程安全的特定方面，如 Send 和 Sync、guards 和 cell。
对于 C 库，没有这样的说法：“可以在一个线程上分配它，在另一个线程上释放它，但不能同时从两个线程中使用它”。
根据数据类型，Rust 描述了线程安全性，它可以泛化到所有使用它们的函数。
对于 C 语言来说，线程安全只涉及单个函数和配置标志。
Rust 的保证通常是在编译时提供的，至少是无条件的。
对于 C 语言，常见的是“仅当 turboblub 选项设置为 7 时，这才是线程安全的”。
Rust 语言支持 async/await异步编程模型。
该编程模型，基于一个叫做 Future 的概念，，在 JavaScript 中也叫做 Promise。Future 表示一个尚未得出的值，你可以在它被解决（resolved）以得出那个值之前对它进行各种操作。在许多语言中，对 Future 所做的工作并不多，这种实现支持很多特性比如组合器（Combinator），尤其是能在此基础上实现更符合人体工程学的 async/await 语法。
Future 可以表示各种各样的东西，尤其适用于表示异步 I/O ：当你发起一次网络请求时，你将立即获得一个 Future 对象，而一旦网络请求完成，它将返回任何响应可能包含的值；你也可以表示诸如“超时”之类的东西，“超时”其实就是一个在过了特定时间后被解决的 Future ；甚至不属于 I/O 的工作或者需要放到某个线程池中运行的CPU密集型的工作，也可以通过一个 Future 来表示，这个 Future 将会在线程池完成工作后被解决。
Future 存在的问题 是它在大多数语言中的表示方式是这种基于回调的方法，使用这种方式时，你可以指定在 Future 被解决之后运行什么回调函数。也就是说， Future 负责弄清楚什么时候被解决，无论你的回调是什么，它都会运行；而所有的不便也都建立在此模型上，它非常难用，因为已经有很多开发者进行了大量的尝试，发现他们不得不写很多分配性的代码以及使用动态派发；实际上，你尝试调度的每个回调都必须获得自己独立的存储空间，例如 crate 对象、堆内存分配，这些分配以及动态派发无处不在。这种方法没有满足零成本抽象的第二个原则，如果你要使用它，它将比你自己写要慢很多，那你为什么还要用它。
Rust 中的方案有所不同。不是由 Future 来调度回调函数，而是由一个被称为执行器（executor）的组件去轮询 Future。而 Future 可能返回“尚未准备就绪（Pending）”，也可能被解决就返回“已就绪（Ready）”。该模型有很多优点。其中一个优点是，你可以非常容易地取消 Future ，因为取消 Future 只需要停止持有 Future。而如果采用基于回调的方法，要通过调度来取消并使其停止就没这么容易了。
同时它还能够使我们在程序的不同部分之间建立真正清晰的抽象边界，大多数其他 Future 库都带有事件循环（event loop），这也是调度 你的Future 执行 I/O 的方法，但实际上你对此没有任何控制权。
而在 Rust 中，各组件之间的边界非常整洁，执行器（executor）负责调度你的 Future ，反应器（reactor）处理所有的 I/O ，然后是你的实际代码。因此最终用户可以自行决定使用什么执行器，使用他们想使用的反应器，从而获得更强的控制力，这在系统编程语言中真的很重要。
而此模型最重要的真正优势在于，它使我们能够以一种真正零成本的完美方式实现这种状态机式的 Future 。也就是当你编写的 Future 代码被编译成实际的本地（native）代码时，它就像一个状态机；在该状态机中，每次 I/O 的暂停点都有一个变体（variant），而每个变体都保存了恢复执行所需的状态。
而这种 Future 抽象的真正有用之处在于，我们可以在其之上构建其他 API 。可以通过将这些组合器方法应用于 Future 来构建状态机，它们的工作方式类似于迭代器（Iterator）的适配器（如 filter、map）。但是这种方式是有一些缺点的，尤其是诸如嵌套回调之类，可读性非常差。所以才需要实现 async / await异步语法。
目前 Rust 生态中，已经有了成熟的 tokio[5] 运行时生态，支持 epoll 等异步 I/O。如果你想用 io_uring ，也可以使用 Glommio[6] ，或者等待 tokio 对 io_uring 的支持。甚至，你可以使用 smol 运行时提供的 async_executor[7] 和 async-io[8] 来构建你自己的运行时。
Rust 可以支持类似于 Cpp 那样的 编译期常量求值。这一点是明显比C优越的。
虽然目前功能还不如 Cpp 那样强大，但还在不断的维护中。
为什么 Rust 中支持 编译期计算这么谨慎呢？因为Rust 编译期求值是必须要保证安全的，所以有很多考虑。Rust 编译期求值不像 Cpp 那样自由且容易滥用。
2020 年 6月份，来自3所大学的5位学者在ACM SIGPLAN国际会议（PLDI'20）上发表了一篇研究成果，针对近几年使用Rust语言的开源项目中的安全缺陷进行了全面的调查。这项研究调查了5个使用Rust语言开发的软件系统，5个被广泛使用的Rust库，以及两个漏洞数据库。调查总共涉及了850处unsafe代码使用、70个内存安全缺陷、100个线程安全缺陷。
在调查中，研究员不光查看了所有漏洞数据库中报告的缺陷和软件公开报告的缺陷，还查看了所有开源软件代码仓库中的提交记录。通过人工的分析，他们界定出提交所修复的BUG类型，并将其归类到相应的内存安全/线程安全问题中。所有被调查过的问题都被整理到了公开的Git仓库中：https://github.com/system-pclub/rust-study[9]
调查结果说明：
Rust语言的safe代码对于空间和时间内存安全问题的检查非常有效，所有稳定版本中出现的内存安全问题都和unsafe代码有关。
虽然内存安全问题都和unsafe代码有关，但大量的问题同时也和safe代码有关。有些问题甚至源于safe代码的编码错误，而不是unsafe代码。
线程安全问题，无论阻塞还是非阻塞，都可以在safe代码中发生，即使代码完全符合Rust语言的规则。
大量问题的产生是由于编码人员没有正确理解Rust语言的生命周期规则导致的。
有必要针对Rust语言中的典型问题，建立新的缺陷检测工具。
那么这份调查报告背后 Rust 的安全性是如何保证的呢？Unsafe Rust 又是为什么 Unsafe 呢？
Rust 的设计深深地吸取了关于安全系统编程的学术研究的精髓。特别是，与其他主流语言相比，Rust 设计的最大特色在于采用了（在学术文献中通常称为或类型系统36[10]）。
所有权机制，就是Rust 语言借助类型系统，承载其“内存安全”的思想，表达出来的安全编程语义和模型。
所有权机制要解决的内存不安全问题包括：
引用空指针。
使用未初始化内存。
释放后使用，也就是使用悬垂指针。
缓冲区溢出，比如数组越界。
非法释放已经释放过的指针或未分配的指针，也就是重复释放。
注意，内存泄露不属于内存安全问题范畴，所以 Rust 也不解决内存泄露问题。
所有权系统。每个被分配的内存都有一个独占其所有权的指针。只有当该指针被销毁时，其对应的内存才能随之被释放。
借用和生命周期。每个变量都有其生命周期，一旦超出生命周期，变量就会被自动释放。如果是借用，则可以通过标记生命周期参数供编译器检查的方式，防止出现悬垂指针，也就是释放后使用的情况。
其中所有权系统还包括了从现代 C++ 那里借鉴的 RAII 机制，这是 Rust 无 GC 但是可以安全管理内存的基石。
建立了安全内存管理模型之后，再用类型系统表达出来即可。
没有空指针
默认不可变
表达式
高阶函数
代数数据类型
模式匹配
泛型
trait 和关联类型
本地类型推导
仿射类型（Affine Type），该类型用来表达 Rust 所有权中的 Move 语义。
借用、生命周期。
借助类型系统的强大，Rust 编译器可以在编译期对类型进行检查，看其是否满足安全内存模型，在编译期就能发现内存不安全问题，有效地阻止未定义行为的发生。
内存安全的 Bug 和并发安全的 Bug 产生的内在原因是相同的，都是因为内存的不正当访问而造成的。同样，利用装载了所有权的强大类型系统，Rust 还解决了并发安全的问题。Rust 编译器会通过静态检查分析，在编译期就检查出多线程并发代码中所有的数据竞争问题。
为了和现有的生态系统良好地集成，Rust 支持非常方便且零成本的 FFI 机制，兼容 C-ABI，并且从语言架构层面上将 Rust 语言分成 Safe Rust 和 Unsafe Rust 两部分。
其中 Unsafe Rust 专门和外部系统打交道，比如操作系统内核。之所以这样划分，是因为 Rust 编译器的检查和跟踪是有能力范围的，它不可能检查到外部其他语言接口的安全状态，所以只能靠开发者自己来保证安全。
Rust 的最终目标并不是完全消除那些危险点，因为在某种程度上，我们需要能够访问内存和其他资源。实际上，Rust 的目标是将所有的unsafe元素抽象出来。在考虑安全性时，你需要考虑“攻击面”，或者我们可以与程序的哪些部分进行交互。像解析器这样的东西是一个很大的攻击面，因为：
它们通常可以被攻击者访问；
攻击者提供的数据可以直接影响解析通常需要的复杂逻辑。
你可以进一步分解，将传统的攻击面分解成“攻击面”（可以直接影响程序代码的部分）和“安全层”，这部分代码是攻击面依赖的代码，但是无法访问，而且可能存在潜在的 Bug。在 C 语言中，它们是一样的：C 语言中的数组根本不是抽象的，所以如果你读取了可变数量的项，就需要确保所有的不变量都保持不变，因为这是在不安全层中操作，那里可能会发生错误。
所以，Rust 提供了 unsafe 关键字和unsafe块，显式地将安全代码和访问外部接口的不安全代码进行了区分，也为开发者调试错误提供了方便。Safe Rust 表示开发者将信任编译器能够在编译时保证安全，而 Unsafe Rust 表示让编译器信任开发者有能力保证安全。
有人的地方就有 Bug。Rust 语言通过精致的设计，将机器可以检查控制的部分都交给编译器来执行，而将机器无法控制的部分交给开发者自己来执行。
Safe Rust 保证的是编译器在编译时最大化地保障内存安全，阻止未定义行为的发生。
Unsafe Rust 用来提醒开发者，此时开发的代码有可能引起未定义行为，请谨慎！人和编译器共享同一个“安全模型”，相互信任，彼此和谐，以此来最大化地消除人产生 Bug 的可能。
Unsafe Rust，是Rust的安全边界。世界的本质就是Unsafe的。你无法避免它。还有人说，因为Unsafe Rust的存在，所以也不见得能比C/C++安全到哪里去？Unsafe Rust确实和C/C++一样，要靠人来保证它的安全。但它对人的要求更高。
它也给了开发者一个Unsafe的边界，这其实也是一种安全边界。它把你代码里的雷区，显式地标记了出来。团队代码里review的话，可以更快地发现问题。这本身就是一种安全。而反观C++，你写出的每一行代码都是Unsafe的，因为它没有像Rust这样明显的界限（Unsafe 块）。
能用Safe Rust就用Safe Rust；
为了性能可以使用Unsafe Rust；
在使用Unsafe Rust的时候确保不要产生UB，并且尽量判断其安全边界，抽象为 Safe 方法；
如果无法抽象为Safe，需要标注为Unsafe，并配以产生UB的条件文档；
对于Unsafe的代码，大家可以重点review。
所以，Unsafe 使用不当也会引发内存安全或逻辑 Bug 。所以，学习 如何对 Unsafe Rust 进行安全抽象至关重要。
不过，Rust 社区生态中有一个 Rust 安全工作组，该组提供 cargo-audit等一系列工具[11]，并且维护`RustSecurity` 安全数据库库[12]中记录的Rust生态社区中发现的安全问题。可以方便地检查 Rust 项目中依赖库的安全问题。
编程语言生产力，大概可以通过以下三个方面来评估：
学习曲线。
语言工程能力。
学习曲线的高低，依个人水平不同而不同。以下罗列了不同基础学习 Rust 应该注意的地方。
完全零基础的开发者：掌握计算机基础体系知识结构，理解Rust语言和硬件/OS层的抽象，理解Rust语言核心概念、以及它的抽象模式，选择Rust语言的某个适用领域进行实操训练，通过实践来提升Rust语言的熟练度和理解深度，同时掌握领域知识。
有C语言基础：由于C语言开发者对高级语言的抽象不是很理解，所以着重了解掌握Rust所有权机制，包括所有权的语义，生命周期和借用检查。了解Rust语言的抽象模式，主要是类型和trait；以及Rust本身的的OOP和函数式语言特性。
有C++基础：C++开发者对于Rust语言的所有权有很好的理解能力，主要精力放在Rust的抽象模式和函数式语言特性上。
有Java/Python/Ruby基础：着重理解攻克Rust所有权机制、抽象模式、函数式编程语言特性。
有Go基础：Go语言开发者比较容易理解Rust的类型和trait抽象模式，但Go也是GC语言，所以所有权机制和函数式语言特性是他们的学习重点。
有Haskell基础：Haskell系的开发者对Rust语言函数式特性能很好的理解，主要攻克所有权机制和OOP语言特性。
所以，对于有一定基础的开发者来说，学习Rust语言要掌握的几个关键概念有：
1、Rust所有权机制，包括所有权的语义，生命周期和借用检查
所有权机制是Rust语言最核心的特性，它保证了在没有垃圾回收机制下的内存安全，所以对于习惯了GC的开发者，理解Rust的所有权是最关键的一环，切记这三点：
Rust中的每一个值都有一个被称为其所有者 (owner)的变量。
值有且只有一个所有者。
当所有者（变量）离开作用域，这个值将被丢弃。这其中又涉及到生命周期和借用检查等概念，是相对比较难啃的一块硬骨头。
2、Rust语言的抽象模式，主要是类型和trait。trait借鉴了Haskell中的Typeclass，它是对类型行为的抽象，可以通俗地类比为其他编程语言里的接口，它告诉编译器一个类型必须提供哪些功能语言特性。使用时要遵循一致性，不能定义相互冲突的实现。
3、OOP语言特性。熟悉面向对象编程（OOP）的常见的四个特性：对象、封装、继承和多态，可以更好地理解Rust的一些特性，比如impl、pub、trait等等。
4、函数式语言特性。Rust语言的设计深受函数式编程的影响，看到函数式特性，数学不好的人可能会望而却步，因为函数式编程语言的最大特点是把运算过程尽量写成一系列嵌套的函数调用,在Rust中，掌握闭包和迭代器是编写函数式语言风格的高性能Rust代码的重要一环。
Rust 已经为开发工业级产品做足了准备。
Rust 引入了强大的类型系统和所有权系统，不仅保证内存安全，还保证了并发安全，同时还不会牺牲性能。
Rust 从 C++那里借鉴了确定性析构、RAII 和智能指针，用于自动化地、确定性地管理内存，从而避免了 GC 的引入，因而就不会有“世界暂停”的问题了。这几项虽然借鉴自 C++，但是使用起来比 C++更加简洁。
Rust 重新审视了错误处理机制。日常开发中一般有三类非正常情况：失败、错误和异常。但是像 C 语言这种面向过程的语言，开发者只能通过返回值、goto 等语句进行错误处理，并且没有统一的错误处理机制。而 C++和 Java 这种高级语言虽然引入了异常处理机制，但没有专门提供能够有效区分正常逻辑和错误逻辑的语法，而只是统一全局进行处理，导致开发者只能将所有的非正常情况都当作异常去处理，这样不利于健壮系统的开发。并且异常处理还会带来比较大的性能开销。
Rust 语言针对这三类非正常情况分别提供了专门的处理方式，让开发者可以分情况去选择。
对于失败的情况，可以使用断言工具。
对于错误，Rust 提供了基于返回值的分层错误处理方式，比如 Option 可以用来处理可能存在空值的情况，而 Result 就专门用来处理可以被合理解决并需要传播的错误。
对于异常，Rust 将其看作无法被合理解决的问题，提供了线程恐慌机制，在发生异常的时候，线程可以安全地退出。
通过这样精致的设计，开发者就可以从更细的粒度上对非正常情况进行合理处理，最终编写出更加健壮的系统。
，Rust 使用 特质（trait） 来作为零成本抽象的基础。特质 面向组合而非继承，让开发者可以灵活地架构 紧耦合 和 松耦合的系统。Rust 也提供了 泛型 来表达类型抽象，结合 trait 特性，让 Rust 拥有静态多态 和 代码复用 的能力。泛型和trait 让你可以灵活使用各种设计模式来对系统架构进行重塑。
，Rust 引入了基于宏的元编程机制。Rust提供了两种宏，分别是声明宏和过程宏。声明宏的形式和C的宏替换类似，区别在于Rust会对宏展开后的代码进行检查，在安全方面更有优势。过程宏则让 Rust 在代码复用、代码生成拥有强大的能力。
，Rust 支持非常方便且零成本的 FFI 机制，兼容 C-ABI，并且从语言架构层面上将 Rust 语言分成 Safe Rust 和 Unsafe Rust 两部分。其中 Unsafe Rust 专门和外部系统打交道，比如操作系统内核。之所以这样划分，是因为 Rust 编译器的检查和跟踪是有能力范围的，它不可能检查到外部其他语言接口的安全状态，所以只能靠开发者自己来保证安全。Unsafe Rust 提供了 unsafe 关键字和 unsafe 块，显式地将安全代码和访问外部接口的不安全代码进行了区分，也为开发者调试错误提供了方便。Safe Rust 表示开发者将信任编译器能够在编译时保证安全，而 Unsafe Rust 表示让编译器信任开发者有能力保证安全。
有人的地方就有 Bug。Rust 语言通过精致的设计，将机器可以检查控制的部分都交给编译器来执行，而将机器无法控制的部分交给开发者自己来执行。Safe Rust 保证的是编译器在编译时最大化地保障内存安全，阻止未定义行为的发生。Unsafe Rust 用来提醒开发者，此时开发的代码有可能引起未定义行为，请谨慎！人和编译器共享同一个“安全模型”，相互信任，彼此和谐，以此来最大化地消除人产生 Bug 的可能。
，Rust 提供了非常好用的包管理器Cargo[13]。Rust 代码是以包（crate）为编译和分发单位的，Cargo 提供了很多命令，方便开发者创建、构建、分发、管理自己的包。Cargo 也提供插件机制，方便开发者编写自定义的插件，来满足更多的需求。比如官方提供的 rustfmt 和 clippy 工具，分别可以用于自动格式化代码和发现代码中的“坏味道”。再比如，rustfix 工具甚至可以帮助开发者根据编译器的建议自动修复出错的代码。Cargo 还天生拥抱开源社区和 Git，支持将写好的包一键发布到 crates.io 网站，供其他人使用。
为了方便开发者学习 Rust，Rust 官方团队做出了如下努力：
独立出专门的社区工作组，编写官方 Rust Book，以及其他各种不同深度的文档，比如编译器文档、nomicon book 等。甚至组织免费的社区教学活动 Rust Bridge，大力鼓励社区博客写作，等等。
Rust 语言的文档支持 Markdown 格式，因此 Rust 标准库文档表现力丰富。生态系统内很多第三方包的文档的表现力也同样得以提升。
提供了非常好用的在线 Playground 工具，供开发者学习、使用和分享代码。
Rust 语言很早就实现了自举，方便学习者通过阅读源码了解其内部机制，甚至参与贡献。
Rust 核心团队一直在不断改进 Rust，致力于提升 Rust 的友好度，极力降低初学者的心智负担，减缓学习曲线。比如引入 NLL 特性来改进借用检查系统，使得开发者可以编写更加符合直觉的代码。
虽然从 Haskell 那里借鉴了很多类型系统相关的内容，但是 Rust 团队在设计和宣传语言特性的时候，会特意地去学术化，让 Rust 的概念更加亲民。
在类型系统基础上提供了混合编程范式的支持，提供了强大而简洁的抽象表达能力，极大地提升了开发者的开发效率。
提供更加严格且智能的编译器。基于类型系统，编译器可以严格地检查代码中隐藏的问题。Rust 官方团队还在不断优化编译器的诊断信息，使得开发者可以更加轻松地定位错误，并快速理解错误发生的原因。
，Rust 社区还提供了强大的 IDE 支持。VSCode/Vim/Emacs + 成为了 Rust 开发的标配。当然 的 IDEA/ Clion 也对 Rust 支持十分强力。
Rust 语言自身作为一个开源项目，也是现代开源软件中的一颗璀璨的明珠。
在 Rust 之前诞生的所有语言，都仅仅用于商用开发，但是 Rust 语言改变了这一状况。对于 Rust 语言来说，Rust 开源社区也是语言的一部分。同时，Rust 语言也是属于社区的。
Rust 团队由 Mozilla 和非 Mozilla 成员组成，至今 Rust 项目贡献者已经超过了 1900 人。Rust 团队分为核心组和其他领域工作组，针对 Rust 2018 的目标，Rust 团队被分为了嵌入式工作组、CLI 工作组、网络工作组以及 WebAssembly 工作组，另外还有生态系统工作组和社区工作组等。
这些领域中的设计都会先经过一个 RFC 流程，对于一些不需要经过 RFC 流程的更改，只需要给 Rust 项目库提交 Pull Request 即可。所有过程都是对社区透明的，并且贡献者都可参与评审，当然，最终决策权归核心组及相关领域工作组所有。后面为了精简 FCP流程，也引入了 MCP。
Rust 团队维护三个发行分支：稳定版（Stable）、测试版（Beta）和开发版（Nightly）。其中稳定版和测试版每 6 周发布一次。标记为不稳定（Unstable）和特性开关（Feature Gate）的语言特性或标准库特性只能在开发版中使用。
在 Rust 基金会成立以后，Rust 团队也在不断探索新的开源治理方案。
Rust 虽然有很多优势，但肯定也存在一些缺点。
Rust 编译速度很慢。虽然 Rust 官方也一直在改进 Rust 编译速度，包括增量编译支持，引入新的编译后端（ cranelift ），并行编译等措施，但还是慢。而且 增量编译目前也有 Bug。
学习曲线陡峭。
IDE 支持不够完善。比如，对宏代码的支持不是很好。
缺乏针对 Rust 语言特有内存不安全问题的各种检测工具。
Rust 生态日趋丰富，很多基础库和框架都会以 包（crate） 的方式发布到 crates.io[14] ，截止目前，crates.io 上面已经有 62981 个 crate，总下载量已经达到 7,654,973,261次。
按包的使用场景分类，Crates.io 最流行的几个场景依次如下：
命令行工具 （3133 crates）
no-std 库 （2778 crates）
开发工具（测试/ debug/linting/性能检测等， 2652 crates）
Web 编程 （1776 crates）
API 绑定 （方便 Rust 使用的特定 api 包装，比如 http api、ffi 相关api等，1738 crates）
网络编程 （1615 crates）
数据结构 （1572 crates）
嵌入式开发 （1508 crates）
加密技术（1498 crates）
异步开发（1487 crates）
算法 （1200 crates）
科学计算（包括物理、生物、化学、地理、机器学习等，1100 crates）
除此之外，还有 WebAssembly 、编码、文本处理、并发、GUI、游戏引擎、可视化、模版引擎、解析器、操作系统绑定 等其他分类，也有不少库。
常用知名基础库和工具链
其中已经涌现出不少优秀的基础库，都可以在 crates.io 首页里看到。这里罗列出一些：
序列化/反序列化：Serde[15]
命令行开发：clap [16]/ structopt[17]
异步/Web/网络开发：tokio [18] / tracing [19] /async-trait [20] / tower [21]/ async-std [22] tonic [23]/ actix-web [24]/smol [25]/ surf [26]/ async-graphql [27]/ warp /[28] tungstenite [29]/ encoding_rs [30]/ loom [31]/ Rocket[32]
FFi 开发：libc [33]/ winapi [34]/ bindgen [35]/ pyo3 [36]/ num_enum [37]/ jni [38]/ rustler_sys[39]/ cxx [40]/ cbindgen [41]/ autocxx-bindgen [42]
API 开发: jsonwebtoken [43]/ validator [44]/ tarpc [45]/ nats [46]/ tonic[47]/ protobuf [48]/ hyper [49]/ httparse [50]/ reqwest [51] / url [52]
解析器：nom [53]/ pest [54]/ csv [55]/ combine [56]/ wasmparser [57]/ ron [58]/ lalrpop [59]
密码学：openssl [60]/ ring [61]/ hmac [62]/ rustls[63] / orion[64] / themis[65] / RustCrypto[66]
WebAssembly: wasm-bindgen[67]/ wasmer [68]/ wasmtime [69]/ yew [70]
数据库开发：diesel [71]/ sqlx [72]/ rocksdb [73]/ mysql [74]/ elasticsearch [75]/ rbatis [76]
并发：crossbeam [77]/ parking_lot [78]/ crossbeam-channel [79]/ rayon [80]/ concurrent-queue[81]/ threadpool [82] / flume [83]
嵌入式开发：embedded-hal [84]/ cortex-m [85]/ bitvec [86]/ cortex-m-rtic [87]/ embedded-dma [88]/ cross [89]/ Knurling Tools[90]
测试：static_assertions [91]/ difference [92]/ quickcheck [93]/ arbitrary [94]/ mockall [95]/ criterion [96]/ proptest[97] / tarpaulin[98]/ fake-rs[99]
多媒体开发：rust-av[100]/ image[101]/ svg [102]/ rusty_ffmpeg[103]/ Symphonia[104]/
游戏引擎和基础组件：glam [105]/ sdl2 [106]/ bevy [107]/ amethyst[108]/ laminar[109]/ ggez [110]/ tetra[111]/ hecs[112]/ simdeez[113]/ rg3d [114] / [rapier](https://github.com/dimforge/ra pier "rapier") / Rustcraft[115] Nestadia[116]/ naga[117]/ Bevy Retro[118]/ Texture Generator[119] / building_blocks[120] / rpg-cli [121]/ macroquad[122]
TUI/GUI 开发：winit [123]/ gtk [124]/ egui [125]/ imgui [126]/ yew [127]/ cursive [128]/ iced [129]/ fontdue [130]/ tauri [131]/ druid [132]
Rust 是一门通用的高级系统级编程语言，其应用领域基本可以同时覆盖 C/Cpp/Java/Go/Python 的应用领域。
具体而言，Rust 的应用领域目前覆盖到以下领域：
下面来盘点不同领域内国内外的 Rust 项目。通过提供代码量、团队规模、项目周期相关数据，希望可以让大家对 Rust 领域应用和开发效率能有一个比较直观的认识。
数据服务领域，包括了数据库，数据仓储，数据流，大数据等。
关键字：数据库/ 分布式系统/ CNCF
TiKV [133]是一个开源的分布式事务 Key-Value 数据库，专注为下一代数据库提供可靠、高质量、实用的存储架构。最初由 PingCAP 团队在 目前，TiKV 已经在知乎、一点资讯、Shopee、美团、京东云、转转等多行业头部企业得到上线应用。
TiKV 通过 Raft 一致性算法来实现数据多副本之间的一致性，本地采用了 RocksDB 存储引擎存储数据，同时 TiKV 支持数据自动切分和迁移。TiKV 的跨行事务最初参考 Google Percolator 事务模型，并进行了一些优化，提供快照隔离与带锁快照隔离，支持分布式事务。
2018 年 8 月被 CNCF 宣布接纳为沙箱云原生项目，在 2019 年 5 月从沙箱晋级至孵化项目。
TiKV 项目 包含 Rust 代码行数大约 30 万行（包含测试代码）。
TiKV 是全球性开源项目，可以从贡献者名单[134]来查看团队规模。TiKV 组织中也包含了一些 Go/Cpp 项目，这个并不算在内，只统计参与 Rust 项目的人力规模。
主力开发：20人左右。
社区贡献：300 多人。
TiKV 是作为 TiDB 的底层存储跟随 TiDB 演进。TiDB 为 Go 开发，TiKV 为 Rust 开发。
2016 年 1 月作为 TiDB 的底层存储引擎设计并开发 。
2016 年 4 月开源 发布第一版。
2017 年 10 月 16 日，TiDB 发布 GA 版（TiDB 1.0）， TiKV 发布 1.0 。
2018 年 4 月 27 日，TiDB 发布 2.0 GA 版， TiKV 发布 2.0 。
2019 年 6 月 28 日，TiDB 发布 3.0 GA 版本， TiKV 发布 3.0 。
2020 年 5 月 28 日，TiDB 发布 4.0 GA 版本， TiKV 发布 4.0。
2021 年 4 月 07 日，TiDB 发布 5.0 GA 版本， TiKV 发布 5.0。
有些朋友可能比较关注 Rust 开发效率如何，并且想对其量化，尤其是想对比 C/ Cpp / Go 等其他语言的开发效率。
私以为量化开发效率是非常困难的，尤其是和其他语言比较的量化。我们不妨换个角度来看这件事，比如，从敏捷项目迭代管理来看这件事。如果一门语言，可以满足日常的敏捷开发迭代需求，可以帮助完成产品的进化，那足以说明这门语言的开发效率了。
据了解，PingCAP 中 Go 开发人员是 Rust 开发人员的四五倍之多，当然工作量也差不多是这样的比例。从上面的数据，我们可以看得出来， Rust 项目（TiKV）依然可以稳步跟得上 Go 项目（TiDB）的迭代节奏，说明 Rust 的开发效率还是足以胜任现代化开发需求。
关键字：实时数据仓库/ 创业/ 天使轮
TensorBase[135] 是金明剑博士于 2020 年 8月启动的创业项目，从一个现代的全新视角出发，用开源的文化和方式，重新构建一个Rust下的实时数据仓库，服务于这个海量数据时代的数据存储和分析。TensorBase 项目目前已获得世界知名创业投资加速机构的天使轮投资。
因为 TensorBase 是构建于 Apache Arrow[136] 和 Arrow DataFusion[137] 之上，所以代码统计排除掉这两个项目的依赖。
TensorBase 核心代码行数 54000 多行。
团队规模：
主力开发：1人。
社区贡献：13 人。
因为是新项目，开源社区还在建设中。
TensorBase 以时间为节奏发版，而非语义版。迭代周期预计 一年一个大版本，一月一个小版本。
从 2021年 4 月 20 正式发版，到最近 6月 16，保持这个节奏。
关键字：Dataflow/ 分布式系统/创业
Timely Dataflow[138] 是 基于微软 这篇 Timely Dataflow 论文：《Naiad: A Timely Dataflow System》[139]的 现代化 Rust 实现。是 clockworks.io[140] 公司的开源产品。
在分布式系统中对流式数据进行复杂的处理，比如多次迭代或者递增计算是非常困难的。Storm, Streaming Spark, MillWheel 都不能很好的适应各种应用复杂的需求。Naiad 通过引入 timestamp 的概念，给出了一个非常 low-level 的模型，可以用来描述任意复杂的流式计算。
dataflow系统包罗万象，MapReduce，Spark都可以算是其中代表。Timely dataflow 给出了一个完全基于时间的抽象，统一了流式计算和迭代计算。当你需要对流式数据并行处理且需要迭代控制的时候，可以使用 Timely Dataflow 。
Rust 代码量 大约 13000 行。
团队规模：
主力开发：4人。
社区贡献：30多人。
2017年9月7号，0.3.0 版本。
2018年6月28号，0.6.0 版本。
2018年9月16号，0.7.0 版本。
2018年12月3号，0.8.0 版本。
2019年3月31号，0.9.0 版本。
2019年7月10号，0.10.0 版本。
2021年3月10号，0.12.0版本。
基本上 三个月 出 一个 小版本，除了 Timely Dataflow 之外该团队同时还维护一个构建于 Timely Dataflow 之上的 Differential Dataflow[141] ，和 Timely Dataflow 同步迭代。
关键字：数据库/ 学术论文项目
Noria [142] 是一种新的流式数据流系统，旨在作为基于MIT Jon Gjengset[143] 的博士学位论文[144]的重型Web应用程序的快速存储后端，也参考了OSDI'18的论文[145]。它类似于数据库，但支持预计算和缓存关系查询结果，以便加速查询。Noria 自动将缓存的结果保持为底层数据，存储在持久性基础表中。Noria使用部分状态数据流来减少内存开销，并支持动态，运行时数据流和查询更改。
Rust 代码行数大约 59000 多行。
团队规模：
主力贡献者：2人
社区贡献者：21人
因为是个人学术研究项目，所以发布周期没有那么明显。
项目周期 2016年7月30 ~ 2020年 4月30，一共5000多commit。
关键字：数据管道/分布式系统/创业
Vector[146] 是 Timer 公司构建的一款高性能的、端到端的（代理和聚合器）可观察性数据管道。它是开源的，比该领域（Logstash、Fluentd之类）的所有替代方案快10倍。目前像 豆瓣、checkbox.ai、fundamentei、BlockFi、Fly.io 等公司使用了 Vector 。点击此处[147]查看官方性能报告，点击此处[148]查看目前生产环境中使用 Vector 的公司。
代码量大约 18 万行 Rust 代码。
团队规模：
主力开发：9人
社区贡献：140 人
2019年3月22，初始版本发布。
2019年6月10，0.2.0版本发布
2019年7月2，0.3.0版本发布
2019年9月25，0.4.0版本发布
2019年10月11，0.5.0版本发布
2019年12月13，0.6.0版本发布
2020年1月12，0.7.0版本发布
2020年2月26，0.8.0版本发布
2020年4月21，0.9.0版本发布
2020年7月23，0.10.0版本发布
2021年3月12，0.11.0 ～ 0.12 版本发布
2021年4月22，0.13.0版本发布
2021年6月3，0.14.0版本发布
关键字：大数据/数据格式标准/Apach
arrow-rs[149] 是 Apache Arrow 的 Rust 实现。Apache Arrow 是 一种适合异构大数据系统的内存列存数据格式标准。它有一个非常大的愿景：提供内存数据分析 (in-memory analytics) 的开发平台，让数据在异构大数据系统间移动、处理地更快。
Arrow 从 2.0 版本开始引入 Rust[150] ，从 4.0 开始 Rust 实现迁移到了独立仓库 arrow-rs 。
Arrow的Rust实现实际上由几个不同的项目组成，包括以下几个独立 crate 和 库 ：
arrow[151]，arrow-rs 核心库，包含在 arrow-rs 中。
arrow-flight [152]，arrow-rs 组件之一，包含在 arrow-rs 中。
parquet[153]，arrow-rs 组件之一，包含在 arrow-rs 中。在大数据生态内，Parquet 是最为流行的文件存储格式。
DataFusion[154]，一个可扩展的内存查询执行引擎，使用Arrow作为其格式。
Ballista[155]，一个分布式计算平台，由Apache Arrow和DataFusion驱动，包含在 DataFusion 中。
arrow-rs 各相关组件加起来，Rust 代码量 大约 18 万行。
团队规模：
主力开发：大约 10 人
社区贡献：550 多人
项目 DataFusion 在 2016 年就开始构建了，后来进入了 Apache Arrow 项目。
以 arrow-rs 4.0 开始算：
2021 年 4 月 18 ，版本 4.0 发布。
2021 年 5 月 18，版本 4.1 发布。
2021 年 5 月 30， 版本 4.2 发布。
2021 年 6 月11， 版本 4.3 发布。
关键字：时序数据库/分布式
InfluxDB IOx[156]，是 InfluxDB 的下一代时序引擎，使用 Rust + Aarow 来重写。
现有设计主要有以下几个致命性问题：
无法解决时间线膨胀的问题
在云原生环境下，对内存管理要求比较严格，这意味 mmap 不在适用，而且 InfluxDB 需要支持无本地盘的运行模式
由于索引与数据分开存储，导致高效的数据导入导出功能难以实现
上述这三个问题都是现有设计的核心之处，因此要想支持现阶段需求，重写是个比较好的选择。
InfluxDB IOx 代码量大约是 16万行 Rust 代码。
团队规模：
主力开发：5人
社区贡献：24 人
该项目从 2019年 11月开始立项，但截至到今天此项目还非常早期，它还没有准备好进行测试，也没有任何构建或文档。
但是从 GitHub 活动状态来看，开发状态还非常积极。主要的开发工作都是在2021年开始的。
关键字：时序数据库
CeresDB 是蚂蚁集团研发的一款TP/AP 融合时序数据库，满足金融时序、监控、IOT 等场景下的海量时序数据的存储、多维查询下钻和实时分析需求。有开源计划，但目前暂未开源。
目前数据库开发大约 8-10个人。
其他信息还未可知。
关键字：全文检索/ lucene
tantivy[157] 是一个由 Apache Lucene 启发的全文搜索引擎库，用 Rust 实现。
tantivy 性能卓越，这里有一个基于 Rust + Tantivy + AWS 构建的应用 ：提供十亿网页搜索并生成常见单词云[158]。
代码量大约为 50000 行 Rust 代码。
团队规模：
主力开发：1 人
社区贡献：85人
项目自 2016 年立项，迭代周期为平均一月一个小版本发布，目前发布到 0.15.2 版本。
关键字：知乎/ lucene
Rucene[159] 是知乎团队开源的一款基于 Rust 实现的搜索引擎。Rucene不是完整的应用程序，而是可以轻松用于将完整文本搜索功能添加到应用程序的代码库和API。它是对 Apache Lucene 6.2.1 项目的 Rust 移植。
代码量大约为 10 万 行 Rust 代码。
团队规模：
主力开发：4人
社区贡献：0 人
可能因为是公司内部项目开源化，目前没有迭代出具体语义版本。在知乎内是用于生产环境的。
云原生领域包括：机密计算、Serverless、分布式计算平台、容器、WebAssembly、运维工具等
关键字：容器/ 虚拟化/ Serverless
StratoVirt[160] 是 研发的 基于Rust的下一代虚拟化平台。
Strato，取自stratosphere，意指地球大气层中的平流层，大气层可以保护地球不受外界环境侵害，而平流层则是大气层中最稳定的一层；类似的，虚拟化技术是操作系统平台之上的隔离层，既能保护操作系统平台不受上层恶意应用的破坏，又能为正常应用提供稳定可靠的运行环境；以Strato入名，寓意为保护openEuler平台上业务平稳运行的轻薄保护层。同时，Strato也承载了项目的愿景与未来：轻量、灵活、 安全和完整的保护能力。
StratoVirt是计算产业中面向云数据中心的企业级虚拟化平台，实现了一套架构统一支持虚拟机、容器、Serverless三种场景，在轻量低噪、软硬协同、安全等方面具备关键技术竞争优势。StratoVirt在架构设计和接口上预留了组件化拼装的能力和接口，StratoVirt可以按需灵活组装高级特性直至演化到支持标准虚拟化，在特性需求、应用场景和轻快灵巧之间找到最佳的平衡点。
代码量大约是 27000 行 Rust 代码。
团队规模：
主力开发：4 人。
社区贡献：15人。
2020-09-23，发布 0.1.0 版本。
2021-03-25，发布 0.2.0 版本。
2021-05-28 ，发布 0.3.0 版本。
关键字：容器/ Serverless/ FaaS
Firecracker[161] 由 AWS 发布并将firecracker开源， 它的定位是面向Serverless计算业务场景。Firecracker本质上是基于KVM的轻量级的microVM， 可以同时支持多租户容器和FaaS场景。Security和Fast是firecracker的首要设计目标。它的设计理念可以概括为：
基于KVM
精简的设备集（极简主义）
基于Rust语言（Built