markdeng206 / awesome-rust-list

A collection of some awesome public Rust programming language projects.

Awesome-Rust-List

🔥🔥🔥 This repository lists some awesome public Rust programming language projects.

Contents

• Awesome-Rust-List
  • Summary
    • Official Rust
    • Awesome List
    • Learning Resources
  • Data Structure and Algorithm
  • Design Pattern
  • Memory Allocator
  • Asynchronous Runtime
  • Embedded Development
  • Universal Operating System
  • Robot Operating System
  • Hardware Description Language
  • FFI Bindings
  • GPU Computation
  • Graphics Library
  • Shared Memory
  • Remote Desktop
  • Date and Time
  • Data Encryption
  • Scientific Computation
    • Numerical Calculation
    • Linear Algebra
    • Lie Groups
    • Optimization Algorithm
    • Finite Element Computation
    • Data Analysis and Visualization
  • Sensor and Communication Interface
  • Signal Processing
  • Text Processing
  • Image and Video Processing
  • Localization and Mapping
  • Path Planning
  • Motion Control
  • Game Engine
  • Machine Learning
    • ML Framework
    • Large Language Model
    • Stable Diffusion
    • Object Detection
  • Web Crawler
  • Web Framework
  • WebAssembly Runtime
  • GUI
  • Blogs

Summary

• Official Rust

  • Rust : The Rust Programming Language. Empowering everyone to build reliable and efficient software. www.rust-lang.org. Rust Foundation.

  • std : The Rust Standard Library.

  • Docs.rs : Docs.rs documentation.

  • crates.io : The Rust community’s crate registry.

  • Lib.rs : Fast, lightweight, opinionated, unofficial alternative to crates.io.

  • Rust Playground : The Rust Playground. rust-lang/rust-playground .

• Awesome List

  • rust-unofficial/awesome-rust : A curated list of Rust code and resources.

  • rust-embedded/awesome-embedded-rust : Curated list of resources for Embedded and Low-level development in the Rust programming language.

  • TaKO8Ki/awesome-alternatives-in-rust : A curated list of replacements for existing software written in Rust.

  • rust-in-blockchain/awesome-blockchain-rust : Collect libraries and packages about blockchain/cryptography in Rust.

  • jetli/awesome-yew : 😎 A curated list of awesome things related to Yew / WebAssembly.

  • vaaaaanquish/Awesome-Rust-MachineLearning : This repository is a list of machine learning libraries written in Rust. It's a compilation of GitHub repositories, blogs, books, movies, discussions, papers, etc. 🦀

  • awesome-rust-com/awesome-rust :A curated list of awesome Rust frameworks, libraries and software. awesome-rust

  • rust-cc/awesome-cryptography-rust : Collect libraries and packages about cryptography in Rust.

  • ddotta/awesome-polars : A curated list of Polars talks, tools, examples & articles. Contributions welcome !

  • ex0dus-0x/awesome-rust-security : Curated list of awesome projects and resources related to Rust and computer security.

  • robotics-rs/robotics.rs : List of (awesome) Rust libraries for Robotics.

  • rsasaki0109/RustRobotics : Rust implementation of PythonRobotics such as EKF, DWA, Pure Pursuit, LQR.

• Learning Resources

  • std : The Rust Standard Library.

  • Docs.rs : Docs.rs documentation.

  • Rust Language Cheat Sheet : Rust Language Cheat Sheet - https://cheats.rs. cheats.rs

  • rust-lang/book : The Rust Programming Language. doc.rust-lang.org/book/

  • rust-lang/reference : The Rust Reference. doc.rust-lang.org/nightly/reference/

  • pretzelhammer/rust-blog : pretzelhammer's Rust blog 🦀. Educational blog posts for Rust beginners.

  • ctjhoa/rust-learning : A bunch of links to blog posts, articles, videos, etc for learning Rust.

  • lborb/book : The Little Book of Rust Books. lborb.github.io/book/

  • instrumentisto/rust-incubator : Learning Rust step-by-step. This project represents a hard-way step-by-step Rust learning course from language basics to a capability of web backend development.

  • 1595901624/StudyRust : 公众号：《Rust学习日记》Rust 学习日记 源码 ，让你的Rust从0基础小白到大牛。

  • rust-lang/rust-by-example : Learn Rust with examples (Live code editor included). doc.rust-lang.org/stable/rust-by-example/

  • rust-lang/rustlings : rustlings 🦀❤️. 🦀 Small exercises to get you used to reading and writing Rust code!

  • MacroKata : Welcome to MacroKata, a set of exercises which you can use to learn how to write macros in Rust.

  • veykril/tlborm : The Little Book of Rust Macros (updated fork). veykril.github.io/tlborm/. The Little Book of Rust Macros （Rust 宏小册）

  • dtolnay/proc-macro-workshop : Rust Latam: procedural macros workshop. This repo contains a selection of projects designed to learn to write Rust procedural macros — Rust code that generates Rust code.

  • dtolnay/proc-macro2 : A wrapper around the procedural macro API of the compiler's proc_macro crate.

  • rustomax/rust-iterators : Basic Rust iterator usage. The goal of this tutorial is to provide a handy reference to some of the common iterator patterns.

  • Rust文档网 : Rust 官方文档中文教程。

  • rust-boom/rust-boom : rust awesome（资源）. 💥 rust-boom.github.io/rust-boom/. Rust Boom 是一个仓主在学习使用 Rust 的时候，对 Rust 的一些难点的解决方法以及一些 Rust 开源的好玩的库、书籍、文章的整理，希望可以帮助更多的 Rust 初学者来翻过 Rust 这座大山。

  • Rust程序设计语言 : Rust 程序设计语言 简体中文版。

  • rust-lang-cn/reference-cn : Rust 参考手册 中文版——Chinese translation of The Rust Reference. rustwiki.org/zh-CN/reference

  • sunface/rust-course : Rust语言圣经(Rust Course)。“连续六年成为全世界最受喜爱的语言，无 GC 也无需手动内存管理、极高的性能和安全性、过程/OO/函数式编程、优秀的包管理、JS 未来基石" — 工作之余的第二语言来试试Rust吧。<<Rust语言圣经>>拥有全面且深入的讲解、生动贴切的示例、德芙般丝滑的内容，甚至还有JS程序员关注的 WASM 和 Deno 等专题。这可能是目前最用心的 Rust 中文学习教程。course.rs

  • rust-lang-cn/rust-by-example-cn : Rust By Example 中文版(包含在线代码编辑器)。通过例子学 Rust 中文版

  • sunface/rust-by-practice : Learning Rust By Practice, narrowing the gap between beginner and skilled-dev through challenging examples, exercises and projects. Rust By Practice(Rust语言实战)

  • rust-lang-cn/nomicon-zh-Hans : Rust 秘典（死灵书）。nomicon.purewhite.io/

  • tyrchen/geektime-rust : geektime-rust：我的极客时间 Rust 课程的代码仓库，随课程更新。

  • Warrenren/inside-rust-std-library : 本书主要对RUST的标准库代码进行分析，并试图给出RUST标准库代码的分析脉络。This project try to give a venation of how reading the RUST standard library source code.

  • wtklbm/rust-library-i18n : Rust 核心库和标准库中文翻译，可作为 IDE 工具的智能提示，并生成本地 API 文档。

  • johnthagen/min-sized-rust : 🦀 How to minimize Rust binary size 📦

Data Structure and Algorithm

• krahets/hello-algo : 《Hello 算法》是一本动画图解、能运行、可提问的数据结构与算法入门书，支持 Java, C++, Python, Go, JS, TS, C#, Swift, Zig 等语言。 前往阅读 > hello-algo.com.

• sjinzh/hello-algo-rust-zig : Rust and Zig programming language codes for the famous public project 《Hello, Algorithm》|《 Hello，算法 》 about data structures and algorithms.

• EbTech/rust-algorithms : Common data structures and algorithms in Rust. A collection of classic data structures and algorithms, emphasizing usability, beauty and clarity over full generality.

• rust-unofficial/too-many-lists : Learning Rust With Entirely Too Many Linked Lists.

• rustlang-cn/rust-algos : Rust算法题解，用Rust语言实现常见的算法和数据结构，以及leetcode题解。

• QMHTMY/RustBook : A book about Rust Data Structures and Algorithms.

• matey-jack/dl-list-mini.fs : Simple doubly-linked list in safe Rust.

Design Pattern

• fadeevab/design-patterns-rust : Rust examples for all 23 classic GoF design patterns, and even a little more.

• lpxxn/rust-design-pattern : Rust Design Patterns.

Memory Allocator

• typed-arena : A fast (but limited) allocation arena for values of a single type.

• bumpalo : A fast bump allocation arena for Rust. docs.rs/bumpalo

• generational-arena : A safe arena allocator that allows deletion without suffering from the ABA problem by using generational indices. docs.rs/generational-arena

• tikv/jemallocator : Rust allocator using jemalloc as a backend.

Asynchronous Runtime

• Tokio : A runtime for writing reliable, asynchronous, and slim applications with the Rust programming language.

Embedded Development

• stm32-rs : Community Rust support projects for STM32 microcontrollers.

• rust-embedded : Enabling usage of Rust on Embedded Platforms (Embedded Linux / RTOS / Bare Metal).

• rust-raspberrypi-OS-tutorials : 📚 Learn to write an embedded OS in Rust 🦀

• Tock : A secure embedded operating system for microcontrollers. www.tockos.org

• lobaro/FreeRTOS-rust : This project is based on code from freertos.rs and some additions to simplify the usage of FreeRTOS in embedded applications written in Rust.

• Exein-io/pulsar : A modular and blazing fast runtime security framework for the IoT, powered by eBPF. pulsar.sh

Universal Operating System

• BlogOS : This repository contains the source code for the Writing an OS in Rust series at os.phil-opp.com.

• rCore-Tutorial-v3 : OS kernel labs based on Rust/C Lang & RISC-V 64/X86-32.

• rCore : Rust version of THU uCore OS. Linux compatible.

• zCore : Reimplement Zircon microkernel in Rust.

• RustSBI : RISC-V Supervisor Binary Interface (RISC-V SBI) implementation library in Rust; runs on M or HS mode; good support for embedded Rust ecosystem.

• writing-an-os-in-rust : 《使用Rust编写操作系统》

• Theseus : Theseus is a modern OS written from scratch in Rust that explores 𝐢𝐧𝐭𝐫𝐚𝐥𝐢𝐧𝐠𝐮𝐚𝐥 𝐝𝐞𝐬𝐢𝐠𝐧, novel OS structure, and state management.

• snarkOS : A Decentralized Operating System for Zero-Knowledge Applications.

• thepowersgang/rust_os : An OS kernel written in rust. Non POSIX.

• MOROS : MOROS: Obscure Rust Operating System 🦉

• EuraliOS : A hobby x86-64 operating system written in Rust.

• SIMDeez : A library that abstracts over SIMD instruction sets, including ones with differing widths. SIMDeez is designed to allow you to write a function one time and produce SSE2, SSE41, and AVX2 versions of the function.

• yavkOS : Operating system based off of blog_os, with the goal of running wasm modules as executables.

Robot Operating System

• micro-ROS for Arduino : micro-ROS library for Arduino.

• openrr : Open Rust Robotics. OpenRR (pronounced like "opener") is Open Rust Robotics platform.

• rosrust : rosrust is a pure Rust implementation of a ROS client library.

• ros2_rust : Rust bindings for ROS2.

• r2r : R2R - Easy to use, runtime-agnostic, async rust bindings for ROS2.

• erdos : Dataflow system for building self-driving car and robotics applications.

• rclrust : This is yet another ROS2 client library written in Rust.

• RustDDS : RustDDS is a pure Rust implementation of Data Distribution Service, developed by Atostek Oy.

• ros2-client : ROS2 client library based on RustDDS.

• rosbag-rs : A pure Rust crate for reading ROS bag files.

• rustros_tf : This is a rust port of the ROS tf library.

• urdf-rs : URDF parser using serde-xml-rs for rust.

• urdf-viz : visualize URDF/XACRO file, URDF Viewer works on Windows/MacOS/Linux.

• ros-nalgebra : Generate code to convert geometry_msgs into nalgebra structs, for rosrust.

• strawlab/opencv-ros-camera : Geometric models of OpenCV/ROS cameras for photogrammetry.

• luickk/MinimalRoboticsPlatform : MRP is a minimal microkernel that supports the most fundamental robotic domains. It's thought for highly integrated robotics development.

• newpavlov/rosbag-rs : A pure Rust crate for reading ROS bag files.

• Bonsai : Rust implementation of behavior trees.

• msakuta/rusty-behavior-tree-lite : Lightweight behavior tree implementation in Rust.

Hardware Description Language

• Veryl : Veryl: A Modern Hardware Description Language.

• RustHDL : A framework for writing FPGA firmware using the Rust Programming Language.

• VHDL-LS/rust_hdl : This repository contains a fast VHDL language server and analysis library written in Rust.

• yupferris/kaze : An HDL embedded in Rust. kaze provides an API to describe Modules composed of Signals, which can then be used to generate Rust simulator code or Verilog modules.

FFI Bindings

• PyO3 : Rust bindings for the Python interpreter.

• bindgen : Automatically generates Rust FFI bindings to C (and some C++) libraries.

• C2Rust : C2Rust helps you migrate C99-compliant code to Rust. c2rust.com/

• embed-c : Embed C code at compile time inside Rust using C2Rust.

• rust-cpp : rust-cpp - Embed C++ code directly in Rust.

• cxx : Safe interop between Rust and C++. cxx.rs

• Autocxx : Tool for safe ergonomic Rust/C++ interop driven from existing C++ headers. docs.rs/autocxx

• safer_ffi : Write safer FFI code in Rust without polluting it with unsafe code. getditto.github.io/safer_ffi

• UniFFI : UniFFI - a multi-language bindings generator for Rust. mozilla.github.io/uniffi-rs/

• Diplomat : Experimental Rust tool for generating FFI definitions allowing many other languages to call Rust code.

• Rutie : “The Tie Between Ruby and Rust.”

• suirad/zig-header-gen : Automatically generate headers/bindings for other languages from Zig code.

• kassane/zFFI : CBindgen FFI test.

• emilHof/zigc : Zigc aims to provide the basic functionality for compiling and linking Zig libraries into your Rust projects.

• jeremyBanks/zig_with_cargo : Building Zig libraries in a Rust Cargo package.

• nekodjin/rusty-ziguanas : Experiments in Zig-Rust and Rust-Zig FFI.

• DutchGhost/zigiffy : Rust FFI with Zig.

• DutchGhost/rustiffy : Zig FFI with Rust.

• natanalt/zig2rs : use zig code in rust - a medium effort shitpost.

• ogxd/ffidji : 🐶 FFIDJI is a tool to automatically generate bindings between languages, like calling Rust code from C# for instance.

• Deukhoofd/csharp_binder : A simple library to generate C# bindings for a Rust foreign function interface (FFI).

• toolness/csharpbindgen : A Rust library for generating C# bindings from Rust code.

• Cysharp/csbindgen : Generate C# FFI from Rust for automatically brings native code and C native library to .NET and Unity.

• nikomatsakis/duchess : Experiments with Java-Rust interop.

• antoniusnaumann/cargo-swift : A cargo plugin to easily build Swift packages from Rust code. crates.io/crates/cargo-swift

• tomleavy/safer-ffi-gen : Attribute macro to help automate Rust FFI bindings.

GPU Computation

• rust-gpu : 🐉 Making Rust a first-class language and ecosystem for GPU shaders 🚧 shader.rs

• cudarc : cudarc: minimal and safe api over the cuda toolkit.

• Rust-CUDA : Ecosystem of libraries and tools for writing and executing fast GPU code fully in Rust.

• Vulkano : Safe and rich Rust wrapper around the Vulkan API.

• wgpu : Safe and portable GPU abstraction in Rust, implementing WebGPU API. wgpu.rs

• Ash : Vulkan bindings for Rust.

• arrayfire-rust : Rust wrapper for ArrayFire. ArrayFire is a general-purpose tensor library that simplifies the process of software development for the parallel architectures found in CPUs, GPUs, and other hardware acceleration devices.

• ocl : OpenCL for Rust.

• opencl3 : A Rust implementation of the Khronos OpenCL 3.0 API.

Graphics Library

• rust-skia/rust-skia : Safe Rust bindings to the Skia Graphics Library.

• gtk-rs/gtk4-rs : Rust bindings of GTK 4. gtk-rs.org/gtk4-rs/

• gtk-rs/gtk3-rs : Rust bindings for GTK 3. gtk-rs.org

• SabianF/rust_wgpu_3D_vision : A program to simulate stereoscopic 4D vision, using a virtual 3D retina which is created by rapidly displaying all voxels at varying depths of a 3D volume.

Shared Memory

• elast0ny/shared_memory : A Rust wrapper around native shared memory for Linux and Windows.

Remote Desktop

• RustDesk : Virtual / remote desktop infrastructure for everyone! Open source TeamViewer / Citrix alternative. rustdesk.com.

Date and Time

• Chrono : Chrono: Date and Time for Rust.

Data Encryption

• rustic : rustic - fast, encrypted, deduplicated backups powered by Rust.

Scientific Computation

• Numerical Calculation

  • scilib : A rust crate for mathematics and science. crates.io/crates/scilib

  • fitting-rs : Curve fitting library for Rust. crates.io/crates/fitting

• Linear Algebra

  • mathbench : mathbench is a suite of unit tests and benchmarks comparing the output and performance of a number of different Rust linear algebra libraries for common game and graphics development tasks.

  • ndarray : The ndarray crate provides an n-dimensional container for general elements and for numerics.

  • ndarray-linalg : Linear algebra package for rust-ndarray using LAPACK binding.

  • nalgebra : Linear algebra library for the Rust programming language.

  • glam : A simple and fast 3D math library for games and graphics.

  • faer : faer is a collection of crates that implement low level linear algebra routines in pure Rust. The aim is to eventually provide a fully featured library for linear algebra with focus on portability, correctness, and performance. faer-rs.github.io

  • rust-numpy : PyO3-based Rust bindings of the NumPy C-API.

  • cgmath : A linear algebra and mathematics library for computer graphics.

  • ultraviolet : A wide linear algebra crate for games and graphics.

  • vek : Generic 2D-3D math swiss army knife for game engines, with SIMD support and focus on convenience.

  • static-math : Safe and fast mathematical operations with static arrays in the Rust programming language.

  • custos-math : This crate provides CUDA, OpenCL, CPU (and Stack) based matrix operations using custos.

• Lie Groups

  • sophus-rs : Rust bindings for the C++ implementation of Lie Groups using Eigen.

• Optimization Algorithm

  • OpEn : Optimization Engine (OpEn) is a solver for Fast & Accurate Embedded Optimization for next-generation Robotics and Autonomous Systems.

  • mithi/rusty-genes : Genetic algorithm implementation in Rust with animated visualizations in Python.

• Finite Element Computation

  • FENRIS : A Rust library for building advanced applications with the Finite Element Method (FEM).

  • InteractiveComputerGraphics/higher_order_embedded_fem : Source code for our paper "Higher-order finite elements for embedded simulation".

• Data Analysis and Visualization

  • Polars : Polars. Fast multi-threaded, hybrid-out-of-core DataFrame library in Rust | Python | Node.js.

  • Lance : Lance: modern columnar data format for ML. Convert from parquet in 2-lines of code for 100x faster random access, a vector index, data versioning, and more. Compatible with pandas, duckdb, polars, pyarrow, with more integrations on the way. eto-ai.github.io/lance/

  • Plotters : A rust drawing library for high quality data plotting for both WASM and native, statically and realtimely 🦀 📈🚀

  • Typst : A new markup-based typesetting system that is powerful and easy to learn. Typst is a new markup-based typesetting system that is designed to be as powerful as LaTeX while being much easier to learn and use. typst.app.

  • Rerun : Rerun: Visualization infrastructure for computer vision. Log images, point clouds, etc, and visualize them effortlessly. Built in Rust using egui. rerun.io

Sensor and Communication Interface

• serialport-rs : A cross-platform serial port library in Rust. Provides a blocking I/O interface and port enumeration including USB device information.

• scottlamb/moonfire-nvr : Moonfire NVR, a security camera network video recorder.

• l1npengtul/nokhwa : Cross Platform Rust Library for Powerful Webcam/Camera Capture.

• shirok1/livox-rs : Alternative Livox LiDAR library.

• jerry73204/rust-lidar-utils : Encode and decode Velodyne and Ouster lidar packets in Rust.

• hacknus/serial-monitor-rust : A cross-plattform serial monitor/plotter written entirely in rust.

• apertus-open-source-cinema/axiom-recorder : Software to record moving images from Apertus° AXIOM cameras via USB3 or ethernet.

Signal Processing

• strawlab/adskalman-rs : Kalman filter implementation in Rust.

• nravic/kalmanrs : A (yet to be) comprehensive Kalman Filter library in Rust.

• spdes/kalman-rust : A simple implementation of Kalman filter and RTS smoother in Rust (ndarray).

• hortovanyi/Unscented-Kalman-Filter-Rust : UKF written in Rust based on the C++ UKF from the Udacity SD Car Nanodegree.

• wangxiaochuTHU/yakf : Yet Another Kalman Filter Implementation. As well as Lie Theory (Lie group and algebra) on SE(3). [no_std] is supported by default.

• MichaelMauderer/filter-rs : Kalman filters and other optimal and non-optimal estimation filters in Rust.

• rbagd/rust-linearkalman : Kalman filtering and smoothing in Rust.

Text Processing

• Serde : Serde is a framework for serializing and deserializing Rust data structures efficiently and generically. serde.rs/

• serde-rs/json : Strongly typed JSON library for Rust.

• BurntSushi/rust-csv : A fast and flexible CSV reader and writer for Rust, with support for Serde.

• informationsea/xlsxwriter-rs : Excel file writer for Rust. crates.io/crates/xlsxwriter

Image and Video Processing

• opencv-rust : Rust bindings for OpenCV 3 & 4.

• photon : Photon is a high-performance Rust image processing library, which compiles to WebAssembly, allowing for safe, blazing-fast image processing both natively and on the web. silvia-odwyer.github.io/photon

• image-rs/image : Encoding and decoding images in Rust.

• image-rs/imageproc : An image processing library, based on the image library.

• zshipko/image2-rs : A Rust crate focused on generic image processing for a wide range of image formats and data types.

• rust-ffmpeg : Safe FFmpeg wrapper.

• Simp : 🖼️ Simp is a fast and simple GPU-accelerated image manipulation program.

• rust-cv/cv : Rust CV mono-repo. Contains pure-Rust dependencies which attempt to encapsulate the capability of OpenCV, OpenMVG, and vSLAM frameworks in a cohesive set of APIs.

• jay3332/ril : Rust Imaging Library: A high-level imaging crate for Rust. crates.io/crates/ril

• Futsch1/image-sieve : ImageSieve is a GUI based tool to assist in sorting images based on taken date and similarity, categorize them according to their creation date and archive them in a target folder.

Localization and Mapping

• richardanaya/slamburger : A SLAM algorithm for WebAssembly 🍔

• pekkaran/violet : A toy stereo visual inertial odometry (VIO) system.

• mpizenberg/visual-odometry-rs : Visual Odometry in Rust (vors).

• geoeo/visual_odometry : A rust port of https://github.com/geoeo/Dense_VO.

• geoeo/Vision : Computer Vision stuff in Rust.

Path Planning

• pathfinding : Pathfinding library for rust. This crate implements several pathfinding, flow, and graph algorithms in Rust.

• rrt : RRT (Rapidly-exploring Random Tree) library in Rust.

• gear : Collision Avoidance Path Planning in Rust-lang.

• trajectory : trajectory interpolation library for Rust and robotics.

• marcbone/s_curve : S-Curve trajectory generator written in rust.

• Sollimann/bonsai : Rust implementation of behavior trees.

Motion Control

• k : k: Kinematics library for rust-lang.

• rsasaki0109/RustRobotics : This package is a rust implementation of PythonRobotics. Rust implementation of PythonRobotics such as EKF, DWA, Pure Pursuit, LQR.

• braincore/pid-rs : A PID controller for Rust projects.

• yoshuawuyts/pid-lite : A small PID controller library.

• bohonghuang/rov-host : A cross-platform, high-performance underwater robot controll program written in Rust.

• zaiic/pid_rs : A fairly minimal PID controller implementation in Rust.

• josh-tracey/PIDController : Rust PID Controller library. Rust Crate: https://crates.io/crates/adriftdev_pid

• ua-kxie/pid-ctrl : Flexible pid controller with time delta as argument.

• tana/balance-robot2 : Self-balancing robot using LQR control, written in Rust.

• AlexKaravaev/rust_mpc : MPC racing controller made in ros2-rust.

Game Engine

• Bevy : Bevy is a refreshingly simple data-driven game engine built in Rust. It is free and open-source forever! bevyengine.org

• Fyrox : 3D and 2D game engine written in Rust. fyrox.rs

• Ambient : Ambient is a runtime for building high-performance multiplayer games and 3D applications, powered by WebAssembly, Rust and WebGPU. ambient.run

• Rapier : Rapier is a set of 2D and 3D physics engines for games, animation, and robotics. rapier.rs

• bevy_rapier : Official Rapier plugin for the Bevy game engine.

• Parry : 2D and 3D collision-detection library for Rust. parry.rs

• Eldiron : A cross platform classic RPG game creator written in Rust. www.eldiron.com

Machine Learning

• ML Framework

  • TensorFlow Rust : Rust language bindings for TensorFlow.

  • tch-rs : Rust bindings for the C++ api of PyTorch.

  • Burn : Burn - A Flexible and Comprehensive Deep Learning Framework in Rust. burn-rs.github.io/

  • dfdx : Deep learning in Rust, with shape checked tensors and neural networks.

  • Linfa : A Rust machine learning framework. Linfa aims to provide a comprehensive toolkit to build Machine Learning applications with Rust.

  • SmartCore : The most advanced machine learning library in Rust. SmartCore is a comprehensive library for machine learning and numerical computing. The library provides a set of tools for linear algebra, numerical computing, optimization, and enables a generic, powerful yet still efficient approach to machine learning. smartcorelib.org/

  • tract : Sonos' Neural Network inference engine. Tiny, no-nonsense, self-contained, Tensorflow and ONNX inference

  • ort : A Rust wrapper for ONNX Runtime. docs.rs/ort

  • onnxruntime-rs : This is an attempt at a Rust wrapper for Microsoft's ONNX Runtime (version 1.8).

  • Wonnx : Wonnx is a GPU-accelerated ONNX inference run-time written 100% in Rust, ready for the web.

  • altius : Small ONNX inference runtime written in Rust.

  • ggml : Tensor library for machine learning. Written in C.

  • michaelgiba/ggml-rs : Work in progress rust bindings to ggml.

  • KerfuffleV2/ggml-sys-bleedingedge : Bleeding edge low level Rust binding for GGML.

  • PABannier/rust-ggml : Rust bindings for C tensor library ggml.

  • KerfuffleV2/rusty-ggml : GGML bindings that aim to be idiomatic Rust rather than directly corresponding to the C/C++ interface.

  • goldstraw/RustCNN : Rust convolutional neural network from scratch.

  • elftausend/gradients : Deep Learning library using custos and custos-math.

  • michaelmelanson/spiking-neural-net : A spiking neural network simulation library.

  • AnicetNgrt/neural_networks_rust : Implementing NNs & other machine learning utils in Rust from scratch.

• Large Language Model

  • yetone/openai-translator : The translator that does more than just translation - powered by OpenAI.

  • lencx/ChatGPT : 🔮 ChatGPT Desktop Application (Mac, Windows and Linux). NoFWL.

  • ChatGPT-Desktop : ChatGPT 跨平台客户端，快捷键快速唤醒窗口，问答快人一步！ 基于 tauri + vue3 开发的跨平台桌面端应用。

  • sonnylazuardi/chat-ai-desktop : Chat AI Desktop App. Unofficial ChatGPT desktop app for Mac & Windows menubar using Tauri & Rust.

  • rustformers/llama-rs : Run LLaMA inference on CPU, with Rust 🦀🚀🦙.

  • Noeda/rllama : Rust+OpenCL+AVX2 implementation of LLaMA inference code.

  • m1guelpf/browser-agent : A browser AI agent, using GPT-4. docs.rs/browser-agent

  • sigoden/aichat : Using ChatGPT/GPT-3.5/GPT-4 in the terminal.

  • uiuifree/rust-openai-chatgpt-api : "rust-openai-chatgpt-api" is a Rust library for accessing the ChatGPT API, a powerful NLP platform by OpenAI. The library provides a simple and efficient interface for sending requests and receiving responses, including chat. It uses reqwest and serde for HTTP requests and JSON serialization.

  • Atome-FE/llama-node : Believe in AI democratization. llama for nodejs backed by llama-rs and llama.cpp, work locally on your laptop CPU. support llama/alpaca/gpt4all/vicuna model. www.npmjs.com/package/llama-node

  • sobelio/llm-chain : llm-chain is a collection of Rust crates designed to help you work with Large Language Models (LLMs) more effectively. llm-chain.xyz

  • tazz4843/whisper-rs : Rust bindings to whisper.cpp.

  • 1595901624/gpt-aggregated-edition : 聚合ChatGPT官方版、ChatGPT免费版、文心一言、Poe、chatchat等多平台，支持自定义导入平台。

• Stable Diffusion

  • pykeio/diffusers : modular Rust library for optimized Stable Diffusion inference 🔮 docs.rs/pyke-diffusers

• Object Detection

  • pnn : pnn is Darknet compatible neural nets inference engine implemented in Rust. By optimizing was achieved significant performance increment(especially in FP16 mode). pnn provide CUDNN-based and TensorRT-based inference engines.

  • bencevans/rust-opencv-yolov5 : YOLOv5 Inference with ONNX & OpenCV in Rust.

  • masc-it/yolov5-api-rust : yolov5-api-rust.

  • 12101111/yolo-rs : Yolov3 & Yolov4 with TVM and rust.

  • TKGgunter/yolov4_tiny_rs : A rust implementation of yolov4_tiny algorithm.

  • flixstn/You-Only-Look-Once : A Rust implementation of Yolo for object detection and tracking.

  • lenna-project/yolo-plugin : Yolo Object Detection Plugin for Lenna.

  • gsuyemoto/yolo-rust : Run YOLO computer vision model using Rust and OpenCV and/or Torch.

  • laclouis5/globox-rs : Object detection toolbox for parsing, converting and evaluating bounding box annotations.

Web Crawler

• Spider : Spider: The fastest web crawler and indexer. docs.rs/spider/

• a11ywatch/crawler : A gRPC web indexer turbo charged for performance.

• Antosser/web-crawler : Rust Web Crawler that finds every page, image, and script on a website (and downloads it)

• ravenxd0/crawler : Web Crawler in Rust.

• lonexw/rust-crawler : A simple crawler, built with Rust lang.

• tawilkinson/rust_web_crawler : A simple web crawler in rust.

Web Framework

• Yew : Yew is a modern Rust framework for creating multi-threaded front-end web apps with WebAssembly. yew.rs

• Axum : Ergonomic and modular web framework built with Tokio, Tower, and Hyper.

• Actix : Actix Web is a powerful, pragmatic, and extremely fast web framework for Rust. actix.rs

• Rocket : A web framework for Rust. rocket.rs

• Poem : A full-featured and easy-to-use web framework with the Rust programming language.

• Salvo : Salvo is a powerful and simplest web server framework in Rust world. salvo.rs

• Rouille : Rouille, a Rust web micro-framework.

• Leptos : Build fast web applications with Rust.

• Farm : Super fast web build tool written in Rust - 基于 Rust 的极速 web 构建引擎。 farm-fe.github.io

• zino : zino is a full-featured web application framework for Rust with a focus on productivity and performance.

• Hyper : A terminal built on web technologies. hyper.is

• Deno : Deno is a simple, modern and secure runtime for JavaScript and TypeScript that uses V8 and is built in Rust. deno.land

• SWC : SWC (stands for Speedy Web Compiler) is a super-fast TypeScript / JavaScript compiler written in Rust. swc.rs

• tchatche.rs : tchatche.rs is a blazing fast chat application built with Axum and Yew.rs. tchatche.rs

• tonic : A native gRPC client & server implementation with async/await support. docs.rs/tonic

WebAssembly Runtime

• Wasmer : Wasmer is a fast and secure WebAssembly runtime that enables super lightweight containers to run anywhere: from Desktop to the Cloud, Edge and IoT devices. wasmer.io

• wasmtime : A fast and secure runtime for WebAssembly. wasmtime.dev/

GUI

• Slint : Slint is a toolkit to efficiently develop fluid graphical user interfaces for any display: embedded devices and desktop applications. slint-ui.com

• Tauri : Tauri is a framework for building tiny, blazingly fast binaries for all major desktop platforms. Developers can integrate any front-end framework that compiles to HTML, JS and CSS for building their user interface. The backend of the application is a rust-sourced binary with an API that the front-end can interact with.

• Pake : 🤱🏻 Turn any webpage into a desktop app with Rust. 🤱🏻 很简单的用 Rust 打包网页生成很小的桌面 App.

• egui : egui: an easy-to-use immediate mode GUI in Rust that runs on both web and native.

• Iced : A cross-platform GUI library for Rust focused on simplicity and type-safety. Inspired by Elm.

• Xilem : An experimental Rust architecture for reactive UI.

• Druid : A data-first Rust-native UI toolkit.

• Dioxus : Friendly React-like GUI library for desktop, web, mobile, and more.

• Floem : A native Rust UI library with fine-grained reactivity.

• marek-g/rust-fui : MVVM Rust UI Framework Library.

• KDAB/cxx-qt : Safe interop between Rust and Qt.

• KDE/rust-qt-binding-generator : Generate bindings to use Rust code in Qt and QML.

• apertus-open-source-cinema/narui : A react-inspired UI library for building multimedia desktop apps with rust and vulkan.

• slint-ui/cargo-ui : This is a project to make a GUI for cargo, built using Slint.

Blogs

• 微信公众号「OSC开源社区」
  • 2023-04-05，Slint 1.0正式发布，Rust编写的原生GUI工具包