The Index of Rust Language Project

I am trying to do something on Rust project, before that it needs to build up proper help tools, that is, rebuild some gears. First thing first, I need to know what gears I need that doesn't have a proper implement. So how about make a list/index of the rust I found might useful to me or someone else? Let me do it now.... :)

Standard of my selection

Score

The index only relative to the works i might be interested in.

Not Score

The projects need not be 'awesome' as those 'Awesome XXX project' listed. The index would not be a try of complete list of Rust Language project.

Search Method Description

The results cames from search feature of github UI and keyword as 'Rust' and filter as 'Rust Language'. status:

1. https://github.com/search?l=Rust&p=12&q=rust&type=Repositories
2. https://awesomeopensource.com/projects/rust?projectPage=6

Similar Works

• https://github.com/rust-unofficial/awesome-rust - I have to read it too :D. There are some diff of mine against that list.
• https://crates.io/ - full list of crates.
• https://github.com/rust-windowing/winit/wiki/Missing-features-provided-by-other-crates - About GUI.
• https://github.com/rust-lang-nursery - baby rust projects.
• https://github.com/cmr/this-week-in-rust - Content for this-week-in-rust.org. Made available under CC-BY-SA.
• https://github.com/mre/awesome-static-analysis - This is a collection of static analysis tools and code quality checkers.
• https://github.com/mre/awesome-dynamic-analysis - A curated list of dynamic analysis tools for various programming languages.
• https://github.com/rust-embedded/awesome-embedded-rust - This is a curated list of resources related to embedded and low-level programming in the programming language Rust, including a list of useful crates.
• https://github.com/ZoranPandovski/al-go-rithms - Data Structures and Algorithms Tweet. Clean example implementations of data structures and algorithms written in different languages.
• https://github.com/not-yet-awesome-rust/not-yet-awesome-rust - A curated list of Rust code and resources that do NOT exist yet, but would be beneficial to the Rust community.
• https://github.com/rShetty/awesome-podcasts - awesome blogs, not limited to rust.

Okey, Now the list

Books & newsletters & blogs

• [2019-10-20][Active] https://github.com/rust-lang-nursery/nomicon - The Dark Arts of Advanced and Unsafe Rust Programming. This book digs into all the awful details that are necessary to understand in order to write correct Unsafe Rust programs. Due to the nature of this problem, it may lead to unleashing untold horrors that shatter your psyche into a billion infinitesimal fragments of despair.
• [2019-10-20][Active] https://github.com/rust-lang-nursery/reference - Official of The Rust Language Reference
• [2019-10-18][Active] https://github.com/rust-lang/book
• [2019-10-18][Died] https://github.com/rustcc/RustPrimer - great book.
• [2019-10-18][Active] https://github.com/rust-lang/rust-clippy - A collection of lints to catch common mistakes and improve your Rust code.
• [2019-10-18][Active] https://github.com/nrc/r4cppp - A Rust tutorial for experienced C and C++ programmers.
• [2019-10-18][Died] https://github.com/stevedonovan/gentle-intro
• [2019-10-20][Active] https://github.com/rust-lang-nursery/failure/
• [2019-10-23][Active] https://github.com/flosse/rust-web-framework-comparison - A comparison of some web frameworks and libs written in Rust.
• [2019-10-23][Active] https://github.com/cmr/this-week-in-rust/ - https://this-week-in-rust.org/
• [2019-10-22][Active] https://github.com/dtolnay/proc-macro-workshop - This repo contains a selection of projects designed to learn to write Rust procedural macros — Rust code that generates Rust code. Procedural macros in expression position.
• [2019-10-23][Active] https://github.com/crazymykl/rust-koans -Each koan builds up your knowledge of Rust and builds upon itself. By following the failures and errors presented, you will know what to work on next. As you finish one koan file, the next will be added to path_to_enlightenment.rs.
• [2019-10-25][Active] https://docs.rs/releases - docs of Rust?
• [2019-10-25][Active] https://github.com/BurntSushi/rust-error-handling-case-study - Code for the case study in my blog post: http://blog.burntsushi.net/rust-error-handling
• [2019-10-25][Active] https://github.com/pepsighan/rust-web-developer-roadmap - Below you can find a chart demonstrating the path you may take and the libraries you may require to become a Rust Web Developer. This chart is made with inspiration from Golang Developer Roadmap(https://github.com/Alikhll/golang-developer-roadmap/).
• [2019-10-25][Active] http://arewegameyet.com/ - doc/games code/tutorials of game programming
• [2019-10-25][Active] https://erwabook.com/intro/ - Introduction to Rust Web Applications. https://gitlab.com/bstpierre/irwa
• [2019-10-27][Active] https://github.com/japaric/rust-cross - Everything you need to know about cross compiling Rust programs!
• [2019-10-27][Active] https://github.com/mre/idiomatic-rust - A peer-reviewed collection of articles/talks/repos which teach concise, idiomatic Rust. https://github.com/mre/idiomatic-rust/blob/master/CONTRIBUTING.md
• [2019-10-27][Active] https://github.com/bluss/rustfaq - The supplementary Rust FAQ is intended to be extensive, answer questions that are often encountered, and being simple to update. also: https://www.rust-lang.org/en-US/faq.html
• [2019-10-27][Active] https://github.com/rustwasm/book - The Rust and WebAssembly Book. This small book describes how to use Rust and WebAssembly together. It also consists of tutorials with cool exercises.
• [2019-10-28][Active] https://github.com/ZoranPandovski/al-go-rithms - Algorithms written in different programming languages - https://zoranpandovski.github.io/al-go-rithms/
• [2019-10-28][Active] https://github.com/KaiserY/rust-book-chinese - 本文档为 The Rust Programming Language 的中文翻译。
• [2019-10-28][Active] https://github.com/ralfbiedert/cheats.rs - This is the "Rust Language Cheat Sheet". It is for users who are early Rust professionals (experienced programmers, intermediate Rust users), and prefer visual, example-driven content Engineering Rust Web Applications(https://erwabook.com/intro/)
• [2019-10-28][Active] https://github.com/ZhangHanDong/tao-of-rust-codes - Tao Of Rust Codes 《Rust编程之道》随书源码
• [2019-10-28][Active] https://github.com/stevedonovan/gentle-intro - A gentle Rust tutorial.
• [2019-10-29][Active] https://github.com/dtolnay/case-studies - This repository showcases some examples of tricky Rust code that I have encountered during my years working with a variety of advanced macro libraries in Rust (my own and others').
• [2019-10-29][Died] https://github.com/jauhien/iron-kaleidoscope - LLVM tutorial in Rust language
• [2019-10-29][Active] https://github.com/saschagrunert/kubeflow-data-science-on-steroids - The blog post about Kubeflow, including all materials
• [2019-10-29][Active] https://github.com/kelseyhightower/kubernetes-the-hard-way - Bootstrap Kubernetes the hard way on Google Cloud Platform. No scripts
• [2019-10-30][Active] https://github.com/rShetty/awesome-podcasts - awesome blogs, not limited to rust.
• [2019-10-30][Active] https://docs.rust-embedded.org/embedonomicon/ - The embedonomicon walks you through the process of creating a #![no_std] application from scratch and through the iterative process of building architecture-specific functionality for Cortex-M microcontrollers, specified, cortex-m-rt, msp430-rt and riscv-rt.
• [2019-10-30][Active] https://github.com/Gankro/too-many-lists - https://rust-unofficial.github.io/too-many-lists/ -
• [2019-10-30][Active] https://this-week-in-rust.org/ -

Others: http://acm.timus.ru/help.aspx?topic=rust https://www.oreilly.com/programming/free/files/why-rust.pdf https://open.kattis.com/problems http://rosettacode.org/wiki/Rosetta_Code Rosetta Code is a programming chrestomathy site. The idea is to present solutions to the same task in as many different languages as possible, to demonstrate how languages are similar and different, and to aid a person with a grounding in one approach to a problem in learning another

Rust Language General

Bro, don't die! https://github.com/rust-lang/rustup.rs It keeps Rust Programming Language live https://github.com/rust-lang-nursery/reference - Official of The Rust Language Reference https://github.com/rust-lang/rfcs - RFCs

• [2019-10-18][Active] https://github.com/dtolnay/quote - This crate provides the quote! macro for turning Rust syntax tree data structures into tokens of source code.
• [2019-10-20][Active] https://github.com/rust-lang-nursery/rustc-perf - Website for Rust Compiler Performance Monitoring & Benchmarking. https://perf.rust-lang.org
• [2019-10-20][Active] https://github.com/rust-lang-nursery/rust-toolstate - This repository records the compilation and testing status of development tools bundled with the Rust build system.
• [2019-10-20][Active] https://github.com/rust-lang/rust-clippy - A collection of lints to catch common mistakes and improve your Rust code.
• [2019-10-20][Active] https://github.com/rust-lang/miri - An interpreter for Rust's mid-level intermediate representation. An experimental interpreter for Rust's mid-level intermediate representation (MIR). It can run binaries and test suites of cargo projects and detect certain classes of undefined behavior.
• [2019-10-22][Active] https://github.com/mehcode/config-rs - Layered configuration system for Rust applications (with strong support for 12-factor applications).
• [2019-10-22][Active] https://github.com/seanmonstar/try-lock - A light-weight lock guarded by an atomic boolean.
• [2019-10-22][Active] https://github.com/dtolnay/anyhow - A better Box
• [2019-10-22][Active] https://github.com/BurntSushi/ripgrep - ripgrep is a line-oriented search tool that recursively searches your current directory for a regex pattern.
• [2019-10-22][Active] https://github.com/rust-lang/regex - An implementation of regular expressions for Rust. This implementation uses finite automata and guarantees linear time matching on all inputs. https://docs.rs/regex.
• [2019-10-20][Active] https://github.com/rust-lang-nursery/error-chain - take full advantage of Rust's error handling features without the overhead of maintaining boilerplate error types and conversions. It implements an opinionated strategy for defining your own error types, as well as conversions from others' error types.
• [2019-10-20][Active] https://github.com/rust-lang-nursery/rustc-pr-tracking/
• [2019-10-23][Died] https://github.com/contain-rs/cons-list - An immutable singly-linked list, as seen in basically every functional language.
• [2019-10-23][Active] https://github.com/edef1c/libfringe - libfringe is a library implementing safe, lightweight context switches, without relying on kernel services. It can be used in hosted environments (using std) as well as on bare metal (using core).
• [2019-10-23][Active] https://github.com/rust-lang-nursery/rustfix - The goal of this tool is to read and apply the suggestions made by rustc.
• [2019-10-23][Active] https://github.com/Keats/validator - validation of ORM/ODM/framework-agnostic objects.
• [2019-10-27][Active] https://github.com/bluss/indexmap - A safe, pure-Rust hash table which preserves (in a limited sense) insertion order. This was inspired by Python 3.6's new dict implementation (which remembers the insertion order and is fast to iterate, and is compact in memory).
• [2019-10-27][Active] https://github.com/bluss/fast-floats - Experimental (unstable) “fast-math” wrappers for f32, f64.
• [2019-10-27][Active] https://github.com/bluss/matrixmultiply - General matrix multiplication of f32 and f64 matrices in Rust. Supports matrices with general strides.
• [2019-10-27][Active] https://github.com/bluss/rawpointer - Extra methods for raw pointers.
• [2019-10-27][Active] https://github.com/bluss/defmac - A macro to define lambda-like macros inline.
• [2019-10-27][Active] https://github.com/bluss/maplit - Rust container / collection literal macros for HashMap, HashSet, BTreeMap, BTreeSet.
• [2019-10-29][Active] https://awesomeopensource.com/project/lloydmeta/frunk - Functional generic type-level programming in Rust: HList, Coproduct, Generic, LabelledGeneric, Validated, Monoid and friends.
• [2019-10-29][Active] https://github.com/saschagrunert/indextree - tree structure with multithreading support. This arena tree structure is using just a single Vec and numerical identifiers (indices in the vector) instead of reference counted pointers. This means there is no RefCell and mutability is handled in a way much more idiomatic to Rust through unique (&mut) access to the arena. The tree can be sent or shared across threads like a Vec. This enables general multiprocessing support like parallel tree traversals.
• [2019-10-30][Active] https://github.com/saschagrunert/fastcmp - A fast byte slice comparison library. The library is intended to provide a faster byte slice comparison than the standard library. Also raw string literals b"like this" are compareable this way.
• [2019-10-29][Active] https://github.com/rust-lang/stacker - A library to help grow the stack when it runs out of space.
• [2019-11-25][Active] https://github.com/huonw/var - A Rust macro for declaring and initialising multiple mutable variables in a single statement.
• [2019-11-25][Active] https://github.com/goffrie/redfa - A regular expression and DFA library. Supports parsing and manipulating simple regular expressions over Unicode codepoints, and converting them to DFAs. Also has an implementation of Hopcroft's algorithm for DFA minimization.
• [2019-11-25][Died] https://github.com/reem/rust-lazy - Lazy evaluation in Rust.
• [2020-01-13][Died] https://github.com/Armavica/rustlex - Lexical analysers(词法分析) generator for Rust, written in Rust.

Design Pattern

• [2019-10-25][Active] https://github.com/rust-lang-nursery/lazy-static.rs - it is possible to have statics that require code to be executed at runtime in order to be initialized. This includes anything requiring heap allocations, like vectors or hash maps, as well as anything that requires non-const function calls to be computed.
• [2019-10-25][Active] https://github.com/dtolnay/objekt - his crate provides a Clone trait that can be used in trait objects, and a clone_box function that can clone any sized or dynamically sized implementation of Clone. Types that implement the standard library's std::clone::Clone trait are automatically usable this way. more with: https://github.com/kardeiz/objekt-clonable
• [2019-10-25][Active] https://github.com/dtolnay/ghost - This crate provides a #[phantom] attribute that makes it possible to define unit structs with generic parameters. ref: https://doc.rust-lang.org/std/marker/struct.PhantomData.html
• [2019-10-25][Active] https://github.com/riker-rs/riker - Easily build efficient, highly concurrent and resilient applications. An Actor Framework for Rust.
• [2019-10-25][Died] https://github.com/huytd/mvvm-rs - MVVM Pattern Implementation in Rust
• [2019-10-25][Active] https://github.com/spacejam/tla-rust - writing correct lock-free and distributed stateful systems in Rust, assisted by TLA+. verify core lock-free and distributed algorithms in use with rsdb and rasputin with TLA+. Write an implementation in Rust. Use quickcheck and abstracted RPC/clocks to simulate partitions and test correctness under failure conditions.
• [2019-10-29][Active] https://github.com/emoon/dynamic_reload - Dynamic reloading of shared libraries.
• [2019-10-29][Active] https://github.com/nagisa/rust_libloading/ - A better library for loading dynamic libraries https://docs.rs/libloading

Log

• [2019-10-18][Active] https://github.com/sfackler/log4rs
• [2019-10-18][Active] https://github.com/rust-lang-nursery/log - A Rust library providing a lightweight logging facade.
• [2019-10-22][Active] https://github.com/seanmonstar/pretty-env-logger - A simple logger built on top off env_logger(https://docs.rs/env_logger/0.7.1/env_logger/). It is configured via an environment variable and writes to standard error with nice colored output for log levels.
• [2019-10-22][Active] https://github.com/tokio-rs/tracing - Application level tracing for Rust. https://tokio.rs. is a framework for instrumenting Rust programs to collect structured, event-based diagnostic information.
• [2019-10-22][Active] https://github.com/rust-lang/rust-log-analyzer - Analyzing Travis and Azure Pipelines logs to find encountered errors.The Rust Log Analyzer (RLA) is a tool that analyzes the CI build logs of the rust-lang/rust repository with the purpose of automatically extracting error messages from failed builds.
• [2019-10-28][Active] https://github.com/slog-rs/slog - Structured, contextual, extensible, composable logging for Rust. slog is an ecosystem of reusable components for structured, extensible, composable and contextual logging for Rust. The ambition is to be The Logging Library for Rust. slog should accommodate a variety of logging features and requirements. If there is a feature that you need and standard log crate is missing, slog should have it. This power comes with a little steeper learning curve, so if you experience any problems, please join slog-rs gitter channel to get up to speed. If you'd like to take a quick, convenient route, consider using sloggers wrapper library.
• [2019-10-28][Active] https://github.com/Xudong-Huang/minsql - MinSQL is a log search engine designed with simplicity in mind to the extent that no SDK is needed to interact with it, most programming languages and tools have some form of http request capability (ie: curl) and that's all you need to interact with MinSQL.
• [2019-10-29][Active] https://github.com/awslabs/flowgger - Flowgger is a fast, simple and lightweight data collector written in Rust. It reads log entries over a given protocol, extracts them, decodes them using a given format, re-encodes them into a different format, and asynchronously pushes the result into a remote data store. Flowgger is designed to be: Paranoid: it carefully validates input data to prevent injection of malformed/incomplete records down the chain; Safe: written in Rust, without any unsafe code; Fast: even though messages are systematically parsed and validated, Flowgger is orders of magnitude faster than Logstash and Fluentd; Standalone: it comes as a single executable file, and doesn't require a JVM. Flowgger supports common input types: stdin, UDP, TCP, TLS and Redis, as well as multiple input formats: JSON (GELF), LTSV, Cap'n Proto and RFC5424. Normalized messages can be sent to Kafka, Graylog, to downstream Flowgger servers, or to other log collectors for further processing. https://github.com/awslabs/flowgger/wiki
• [2020-01-13][Died] https://github.com/rubytogether/kirby - Kirby slurps up the firehose of logs from Fastly and calculates daily counts for various Ruby ecosystem statistics, pretty quickly. For an 80MB gzipped log file containing 915,427 JSON event objects (which is 1.02GB uncompressed): 2.7 seconds total to read the entire file line by line; 5.0 seconds total to also parse every JSON object into a Rust struct; 7.8 seconds total to further parse every User Agent field for Bundler, RubyGems, and Ruby versions and other metrics.

Async & Parallel computing

• [2019-10-18][Active] https://github.com/Matthias247/futures-intrusive
• [2019-10-18][Active] https://github.com/tokio-rs/tokio A runtime for writing reliable asynchronous applications with Rust. Provides I/O, networking, scheduling, timers, ... https://tokio.rs
• [2019-10-20][Active] https://github.com/rust-lang-nursery/futures-rs - Zero-cost asynchronous programming in Rust http://rust-lang-nursery.github.io/futures-rs
• [2019-10-22][Active] https://github.com/tokio-rs/async-stream - Asynchronous streams for Rust using async & await notation.
• [2019-10-22][Active] https://github.com/tokio-rs/async - Utilities building on top of Rust's async primitives.
• [2019-10-22][Active] https://github.com/mvdnes/spin-rs - This Rust library implements a simple spinlock, and is safe for #[no_std] environments.
• [2019-10-23][Active] https://github.com/rayon-rs/rayon - A data parallelism library. Rayon is a data-parallelism library for Rust. It is extremely lightweight and makes it easy to convert a sequential computation into a parallel one. It also guarantees data-race freedom. (You may also enjoy this blog post about Rayon, which gives more background and details about how it works, or this video, from the Rust Belt Rust conference.) Rayon is available on crates.io, and API Documentation is available on docs.rs.
• [2019-10-23][Active] https://github.com/wez/cancel-rs - This crate provides a simple token that can be used to co-operatively manage cancellation of an operation. Setting a deadline/timeout is also supported.
• [2019-10-23][Died] https://github.com/dgrunwald/rust-cancellation - CancellationToken for composable cancellation in Rust.
• [2019-10-27][Active] https://gitlab.com/jD91mZM2/xidlehook - xidlehook(https://linux.die.net/man/1/xautolock) is a general-purpose replacement for xautolock. It executes a command when the computer has been idle for a specified amount of time.
• [2019-10-27][Active] https://gitlab.redox-os.org/redox-os/parallel or https://github.com/mmstick/parallel - Redox's Parallel. This is an attempt at recreating the functionality of GNU Parallel, a work-stealer for the command-line, in Rust under a MIT license. The end goal will be to support much of the functionality of GNU Parallel and then to extend the functionality further for the next generation of command-line utilities written in Rust. While functionality is important, with the application being developed in Rust, the goal is to also be as fast and efficient as possible.
• [2019-10-28][Active] https://github.com/async-rs/async-std - provides an async version of std. It provides all the interfaces you are used to, but in an async version and ready for Rust's async/await syntax.
• [2019-10-28][Active] https://github.com/Xudong-Huang/may - May is a high-performant library for programming stackful coroutines with which you can easily develop and maintain massive concurrent programs. It can be thought as the Rust version of the popular Goroutine.
• [2019-10-28][Active] https://github.com/Xudong-Huang/generator-rs - rust stackful generator library
• [2019-10-29][Active] https://github.com/dpc/mioco - Mioco provides green-threads (aka fibers) like eg. Goroutines in Go, for Rust. Rust community decided that futures should be main Rust async IO story, so you might want to look at tokio-fiber: coroutines as Futures project, which should have mioco-like API and allow easily porting code using mioco. ref: https://github.com/dpc/mioco.pre-0.9
• [2019-10-30][Active] https://github.com/nagisa/tokio-periodic - Asynchronous, cross-platform periodic timers. These timers (unlike in tokio-timer, which implements this in user-space) are implemented using the OS facilities in as zero-overhead manner as possible.

Test

• [2019-10-22][Active] https://github.com/crossbario/autobahn-testsuite - used by
• [2019-10-23][Active] https://github.com/BurntSushi/quickcheck - QuickCheck is a way to do property based testing using randomly generated input. This crate comes with the ability to randomly generate and shrink integers, floats, tuples, booleans, lists, strings, options and results. All QuickCheck needs is a property function—it will then randomly generate inputs to that function and call the property for each set of inputs. If the property fails (whether by a runtime error like index out-of-bounds or by not satisfying your property), the inputs are "shrunk" to find a smaller counter-example.
• [2019-10-23][Active] https://github.com/mitsuhiko/rust-incidents - This library provides an experiment for error handling in Rust. It provides efficient error handling and provides powerful debugging features.
• [2019-10-25][Active] https://github.com/BurntSushi/critcmp - A command line tool for comparing benchmarks run by Criterion benchmark harness.
• [2019-10-28][Active] https://github.com/bheisler/criterion.rs - Statistics-driven benchmarking library for Rust. Criterion.rs helps you write fast code by detecting and measuring performance improvements or regressions, even small ones, quickly and accurately. You can optimize with confidence, knowing how each change affects the performance of your code.
• [2019-10-27][Active] https://github.com/ObliqueMotion/rust-criterion-template - A template for writing benchmarks in Rust Crierion.
• [2019-10-25][Active] https://github.com/fcsonline/drill - Drill is a HTTP load testing application written in Rust. The main goal for this project is to build a really lightweight tool as alternative to other that require JVM and other stuff. You can write brenchmark files, in YAML format, describing all the stuff you want to test. It was inspired by Ansible(https://docs.ansible.com/ansible/playbooks_intro.html) syntax because it is really easy to use and extend.
• [2019-10-27][Active] https://github.com/BurntSushi/quickcheck - QuickCheck is a way to do property based testing using randomly generated input. This crate comes with the ability to randomly generate and shrink integers, floats, tuples, booleans, lists, strings, options and results. It should be the same strategy used in Koen Claessen's QuickCheck for Haskell.
• [2019-10-27][Active] https://github.com/petertseng/exercism-rust https://github.com/exercism/rust - At the most basic level, Exercism is all about the tests. You can read more about how we think about test suites in the Exercism documentation.
• [2019-10-27][Died] https://github.com/nikomatsakis/rust-runtime-benchmarks - Some benchmarks for testing rustc performance. It was inspired by Ansible syntax because it is really easy to use and extend.
• [2019-10-30][Active] https://github.com/rust-fuzz/cargo-fuzz - cargo-fuzz is the recommended tool for fuzz testing Rust code. cargo-fuzz is itself not a fuzzer, but a tool to invoke a fuzzer. Currently, the only fuzzer it supports is libFuzzer (through the libfuzzer-sys crate), but it could be extended to support other fuzzers in the future.

System & IO

• [2019-10-22][Active] https://github.com/tokio-rs/mio - Mio is a lightweight I/O library for Rust with a focus on adding as little overhead as possible over the OS abstractions.
• [2019-10-22][Active] https://github.com/tokio-rs/bytes - A utility library for working with bytes.
• [2019-10-22][Died] https://github.com/AtheMathmo/toy-os - Once I had a simple C kernel working I decided to switch to Rust! This was a fairly painful transition initially. Adapting my boot loader proved to be very error prone. Eventually I switched to GRUB and began following Philipp Oppermann's awesome blog(http://os.phil-opp.com/). Which is crazy good.
• [2019-10-22][Active] https://github.com/gz/rust-x86 - Library to program x86 (amd64) hardware. Contains x86 specific data structure descriptions, data-tables, as well as convenience function to call assembly instructions typically not exposed in higher level languages. https://docs.rs/x86
• [2019-10-23][Active] https://github.com/tsgates/rust.ko - A minimal Linux kernel module written in rust.
• [2019-10-23][Active] https://github.com/BurntSushi/ripgrep - ripgrep recursively searches directories for a regex pattern
• [2019-10-23][Died] https://github.com/jwilm/rust_daemon_template - This is a template for writing a daemon using Rust.
• [2019-10-25][Died] https://github.com/BurntSushi/rust-pcre2 - A high level Rust wrapper library for PCRE2 (Perl Compatible Regular Expressions:https://www.pcre.org/).
• [2019-10-23][Active] https://github.com/CraneStation/cranelift - Generates target binary code giving c language?
• [2019-10-25][Active] https://github.com/uutils/platform-info - A cross-platform way to get information about your machine.
• [2019-10-25][Active] https://github.com/uutils/findutils - Rust implementation of GNU findutils.https://www.gnu.org/software/findutils/
• [2019-10-25][Active] https://github.com/uutils/coreutils - Cross-platform Rust rewrite of the GNU coreutils. uutils is an attempt at writing universal (as in cross-platform) CLI utils in Rust. This repo is to aggregate the GNU coreutils rewrites.
• [2019-10-25][Active] https://github.com/uutils/uucore - uucore is a collection of code used by various uutils projects. Currently, almost all of the code is used by uutils/coreutils. In the future, much of this repository may be supplanted by smaller, more focused repositories/crates.
• [2019-10-25][Active] https://github.com/BurntSushi/rust-memchr - The memchr crate provides heavily optimized routines for searching bytes. range from manually tuned Assembly implementations (like that found in GNU's libc) all the way to non-vectorized C implementations (like that found in MUSL).
• [2019-10-25][Active] https://github.com/BurntSushi/walkdir - A cross platform Rust library for efficiently walking a directory recursively. Comes with support for following symbolic links, controlling the number of open file descriptors and efficient mechanisms for pruning the entries in the directory tree.
• [2019-10-27][Active] https://github.com/das-labor/panopticon - A libre program analysis library for machine code. moved to https://gitlab.com/p8n/panopticon. see also https://gitlab.com/p8n/verso
• [2019-10-27][Active] https://gitlab.com/huia-lang/stack-vm - A generic, reusable, stack-based virtual machine for Rust.
• [2019-10-27][Active] https://github.com/darfink/detour-rs - This is a cross-platform detour library developed in Rust. Beyond the basic functionality, this library handles branch redirects, RIP-relative instructions, hot-patching, NOP-padded functions, and allows the original function to be called using a trampoline whilst hooked.
• [2019-10-27][Active] https://github.com/darfink/region-rs - A Rust library for dealing with memory regions. It is implemented using platform specific APIs (e.g VirtualQuery, VirtualLock, mprotect, mlock). Supports: Windows, Linux & Android, macOS & iOS and FreeBSD.
• [2019-10-27][Active] https://github.com/Amanieu/thread_local-rs - This library provides the ThreadLocal and CachedThreadLocal types which allow a separate copy of an object to be used for each thread. This allows for per-object thread-local storage, unlike the standard library's thread_local! macro which only allows static thread-local storage.
• [2019-10-27][Active] https://github.com/danburkert/memmap-rs - cross-platform Rust API for memory mapped IO
• [2019-10-29][Active] https://github.com/redox-os/relibc - relibc is a portable POSIX C standard library written in Rust. It is under heavy development, and currently supports Redox and Linux. The motivation for this project is twofold: Reduce issues the redox crew was having with newlib, and create a safer alternative to a C standard library written in C. It is mainly designed to be used under redox, as an alternative to newlib, but it also supports linux syscalls via the sc crate.
• [2019-10-29][Active] https://github.com/fishinabarrel/linux-kernel-module-rust - Framework for writing Linux kernel modules in safe Rust.
• [2019-11-25][Active] https://github.com/Manishearth/rust-gc - Simple tracing (mark and sweep) garbage collector for Rust
• [2019-11-25][Active] https://github.com/shepmaster/cupid - Get information about the x86 and x86_64 processor

Development, CI (Continuous Integration) or maintainments

• [2019-10-18][Active] https://github.com/rust-lang/rustup.rs
• [2019-10-18][Active] https://github.com/chyh1990/yaml-rust
• [2019-10-18][Active] https://github.com/crossbeam-rs/rfcs - There is a RPC process and templates I could ref for my own.
• [2019-10-22][Active] https://github.com/nix-rust/nix - Rust friendly bindings to nix APIs. ref: https://github.com/NixOS/nixpkgs (Nix Packages collection)
• [2019-10-23][Active] https://github.com/rust-lang/git2-rs - git2-rs works with stable Rust, and typically works with the most recent prior stable release as well. Check the MSRV job of the CI script to see the oldest version of Rust known to pass tests.
• [2019-10-22][Active] https://github.com/mre/idiomatic-rust - A peer-reviewed collection of articles/talks/repos which teach concise, idiomatic Rust.
• [2019-10-25][Active] https://github.com/mgeisler/version-sync - Rust projects typically reference the crate version number in several places, such as the README.md file. The version-sync crate makes it easy to add an integration test that checks that README.md is updated when the crate version changes.
• [2019-10-25][Active] docs.rs — Automatic documentation generation of crates
• [2019-10-25][Active] https://github.com/dtolnay/no-panic -
• [2019-10-26][Active] https://github.com/tree-sitter/tree-sitter - Tree-sitter is a parser generator tool and an incremental parsing library. It can build a concrete syntax tree for a source file and efficiently update the syntax tree as the source file is edited.
• [2019-10-25][Active] https://github.com/dtolnay/automod - Pull in every source file in a directory as a module and test them.
• [2019-10-25][Active] https://github.com/buildfoundation/mainframer - Tool for remote builds. Sync project to remote machine, execute command, sync back.
• [2019-10-25][Active] https://github.com/watchexec/watchexec - Software development often involves running the same commands over and over. Boring! watchexec is a simple, standalone tool that watches a path and runs a command whenever it detects modifications. Example use cases: Automatically run unit tests; Run linters/syntax checkers.
• [2019-10-28][Active] https://github.com/crev-dev/cargo-crev - crev is a general system of preparing cryptographically signed documents (proofs) describing results of code reviews and circulating them between developers to coordinate a distributed ecosystem of code review. cargo-crev is an implementation of crev for Rust programming language, tightly integrated with its package manager: cargo. The goal of cargo-crev is helping Rust community verify and review all the dependencies published on http://crates.io and used by Rust developers.
• [2019-10-28][Active] https://github.com/japaric/trust - Travis CI and AppVeyor template to test your Rust crate on 5 architectures and publish binary releases of it for Linux, macOS and Windows. Features: 1. CI test your crate (library or binary) on Linux, macOS and Windows and on more than just the x86 architecture. 2.Cargo artifacts are cached and reused between CI builds. 3."Deploys": Publish binary releases of your application by just pushing a new (Git) tag. Requirements: 1.Your crate must be hosted on GitHub (free). 2. A Travis CI account (free). 3. An AppVeyor account (free).
• [2019-10-28][Active] https://github.com/Xudong-Huang/rust-embed - Rust Custom Derive Macro which loads files into the rust binary at compile time during release and loads the file from the fs during dev. You can use this to embed your css, js and images into a single executable which can be deployed to your servers. Also it makes it easy to build a very small docker image for you to deploy.
• [2019-10-28][Active] https://github.com/xd009642/tarpaulin - Tarpaulin is designed to be a code coverage reporting tool for the Cargo build system, named for a waterproof cloth used to cover cargo on a ship. Currently, tarpaulin provides working line coverage but is still in the early development stage and therefore may contain some bugs. A lot of work has been done to get it working on some example projects and smaller crates so please report anything you find that's wrong. Also, check out our roadmap for planned features. Tarpaulin aims to be easy to add to your CI workflow. With well tested support for Travis-CI it also supports sending CI specific meta-data to coveralls.io for Circle, Semaphore, Jenkins and Codeship (though only Jenkin's has been tested).
• [2019-10-29][Active] https://github.com/RazrFalcon/cargo-bloat - Find out what takes most of the space in your executable. Inspired by google/bloaty(https://github.com/google/bloaty).
• [2019-10-29][Active] https://github.com/google/rerast - Rerast is a search/replace tool for Rust code using rules. A rule consists of a search pattern, a replacement and possibly some placeholders that can appear in both the search pattern and the replacement. Matching is done on syntax, not on text, so formatting doesn't matter. Placeholders are typed and must match the type found in the code for the rule to apply.
• [2019-10-29][Active] https://github.com/emoon/ProDBG - ProDBG is a new debugger under development that will support a variety of targets and operating systems. Currently it's in very early development and primary focusing on Mac as primary target.
• [2019-10-29][Active] https://github.com/saschagrunert/build-rust - The Docker based Rust build toolchain.
• [2019-10-29][Active] https://github.com/saschagrunert/path - IP based connection identification and tracing. This crate is highly inspired by the netfilter project, which provides connection tracking for TCP/IP based protocols. The timeout of a connection (per default 10 minutes) is handled completely internally by using the time crate.
• [2019-10-30][Active] https://github.com/rust-embedded/cross - “Zero setup” cross compilation and “cross testing” of Rust crates. cross provides all the ingredients needed for cross compilation without touching your system installation and provides an environment, cross toolchain and cross compiled libraries, that produces the most portable binaries. “cross testing” can test crates for architectures other than i686 and x86_64. The stable, beta and nightly channels are supported.
• [2019-10-30][Active] https://github.com/roblabla/cargo-travis - Record total test coverage across in-crate and external tests, and upload to coveralls.io (https://coveralls.io/). coveralls.io help you deliver code confidently by showing which parts of your code aren’t covered by your test suite. Free for open source repos. Pro accounts for private repos. Instant sign up through GitHub, Bitbucket, and Gitlab.

contest

• [2019-10-27][Died] https://github.com/petertseng/adventofcode-rs-2015 -
• [2019-10-27][Died] https://github.com/BurntSushi/advent-of-code - aoc 2018 in rust. https://adventofcode.com/

Algorithms

• [2019-10-18][Died] https://github.com/TheAlgorithms/Rust - the algorthm list is useful. Python/C algorithms are good ref. All algorithms implemented in Rust (for educational purposes). These are for demonstration purposes only.
• [2019-10-18][Active] https://github.com/reem/rust-ordered-float
• [2019-10-18][Active] ttps://github.com/rust-random/rand
• [2019-10-22][Active] https://github.com/EbTech/rust-algorithms - Common data structures and algorithms in Rust. Contest Algorithms in Rust.
• [2019-10-22][Active] https://github.com/rust-num/num - A collection of numeric types and traits for Rust.
• [2019-10-22][Active] https://github.com/rust-ndarray/ndarray - ndarray: an N-dimensional array with array views, multidimensional slicing, and efficient operations https://docs.rs/ndarray/
• [2019-10-22][Died] https://github.com/AtheMathmo/rusty-data - Basic data handling library.
• [2019-10-22][Active] https://github.com/rust-rosetta/rust-rosetta - https://rosettacode.org/wiki/Category:Rust. Rosetta Code is a programming chrestomathy site.
• [2019-10-25][Active] https://github.com/petgraph/fixedbitset - https://github.com/petgraph/fixedbitset
• [2019-10-25][Active] https://github.com/petgraph/petgraph - Graph data structure library. Known to support Rust 1.37 and later. It implements many graph algoithms.
• [2019-10-25][died] https://github.com/eternaleye/rust-critbit - A crit bit tree, also known as a Binary Patricia Trie is a trie (https://en.wikipedia.org/wiki/Trie), also called digital tree and sometimes radix tree or prefix tree (as they can be searched by prefixes), is an ordered tree data structure that is used to store a dynamic set or associative array where the keys are usually strings. Unlike a binary search tree, no node in the tree stores the key associated with that node; instead, its position in the tree defines the key with which it is associated. more ref: https://github.com/jfager/functional-critbit, also http://cr.yp.to/critbit.html
• [2019-10-25][Active] https://github.com/dtolnay/precise - Full precision decimal representation of f64
• [2019-10-25][Active] https://github.com/dtolnay/ryu - Pure Rust implementation of Ryū, an algorithm to quickly convert floating point numbers to decimal strings.
• [2019-10-25][Active] https://github.com/kardeiz/fast-map - A small library and custom derive to create a map-like struct that uses match expressions to get and insert values. If you know your keys at compile-time, this library will likely be faster than HashMap for supported map operations.
• [2019-10-25][Active] https://github.com/tantivy-search/bitpacking - This crate is a Rust port of Daniel Lemire's simdcomp C library.
• [2019-10-25][Active] https://github.com/BurntSushi/rust-snappy - A pure Rust implementation of the Snappy compression algorithm. Includes streaming compression and decompression using the Snappy frame format. This implementation is ported from both the reference C++ implementation and the Go implementation. http://google.github.io/snappy/
• [2019-10-25][Active] https://github.com/BurntSushi/regex-automata - A low level regular expression library that uses deterministic finite automata. It supports a rich syntax with Unicode support, has extensive options for configuring the best space vs time trade off for your use case and provides support for cheap deserialization of automata for use in no_std environments.
• [2019-10-25][Active] https://github.com/BurntSushi/aho-corasick - A library for finding occurrences of many patterns at once with SIMD acceleration in some cases. This library provides multiple pattern search principally through an implementation of the Aho-Corasick algorithm, which builds a finite state machine for executing searches in linear time. Features include case insensitive matching, overlapping matches and search & replace in streams. https://en.wikipedia.org/wiki/Aho%E2%80%93Corasick_algorithm
• [2019-10-25][Active] https://github.com/bheisler/criterion.rs - Criterion.rs helps you write fast code by detecting and measuring performance improvements or regressions, even small ones, quickly and accurately. You can optimize with confidence, knowing how each change affects the performance of your code.
• [2019-10-27][Died] https://github.com/BurntSushi/rust-stats - An experimental library that provides some common statistical functions with some support for computing them efficiently on streams of data. The intent is to permit parallel computation of statistics on large data sets.
• [2019-10-27][Died] https://github.com/BurntSushi/suffix - Fast linear time & space suffix arrays for Rust. Supports Unicode! The big thing missing at the moment is a generalized suffix array. I started out with the intention to build them into the construction algorithm, but this has proved more difficult than I thought.
• [2019-10-27][Died] https://github.com/BurntSushi/rust-sorts - A comparison of different sort algorithms in Rust. This includes mergesort, quicksort, heapsort, insertion sort, selection sort, bubble sort and even bogo sort. The library comes with benchmarks for vectors of different sizes and for vectors that are already sorted or vectors where all elements are equivalent. This library also comes with QuickCheck tests that check whether the result of a sorting algorithm is sorted. Each algorithm is also checked that it is stable/unstable depending on the algorithm used. This is pre-rust 1.0 code. A majority of it will not compile or otherwise work in modern Rust.
• [2019-10-27][Died] https://github.com/BurntSushi/rust-decimal - A Decimal Implementation written in pure Rust suitable for financial calculations.
• [2019-10-28][Active] https://github.com/Xudong-Huang/nonblockinghashmap - Highly Scalable Non-blocking Hash Map in Rust. The design of this hash map is taken and modified from Dr. Cliff Click's design, originally implemented in Java(https://www.youtube.com/watch?v=WYXgtXWejRM).
• [2019-10-29][Active] https://github.com/rust-bio/rust-bio - This library provides implementations of many algorithms and data structures that are useful for bioinformatics. All provided implementations are rigorously tested via continuous integration. ref: https://rust-bio.github.io/.
• [2019-10-29][Active] https://awesomeopensource.com/project/drujensen/fib - Performance Benchmark of top Github languages. The author actually want to tell the world nim (https://github.com/nim-lang) is the fastest programming language of the world.
• [2019-10-29][Active] https://github.com/jonhoo/rust-evmap - A lock-free, eventually consistent, concurrent multi-value map. This map implementation allows reads and writes to execute entirely in parallel, with no implicit synchronization overhead. Reads never take locks on their critical path, and neither do writes assuming there is a single writer (multi-writer is possible using a Mutex), which significantly improves performance under contention.
• [2019-10-29][Active] https://github.com/rust-random/rand - A Rust library for random number generation. Rand provides utilities to generate random numbers, to convert them to useful types and distributions, and some randomness-related algorithms. The core random number generation traits of Rand live in the rand_core crate but are also exposed here; RNG implementations should prefer to use rand_core while most other users should depend on rand. https://rust-random.github.io/book
• [2019-10-29][Active] https://github.com/vbarrielle/sprs - prs implements some sparse matrix data structures and linear algebra algorithms in pure Rust.
• [2019-10-29][Active] https://github.com/rust-lang/libm - The short term goal of this library is to enable math support (e.g. sin, atan2) for the wasm32-unknown-unknown target (cf. rust-lang/compiler-builtins). The longer term goal is to enable math support in the core crate.
• [2019-10-29][Active] https://github.com/strengthen/LeetCode -
• [2019-10-30][Died] https://github.com/nagisa/math.rs - Math software implementations of libm functions in Rust. This is supposed to be linked into Rust binaries on systems where libm is not available.
• [2019-11-25][Active] https://github.com/huonw/fast-math - Fast, approximate versions of mathematical functions.
• [2019-11-25][Active] https://github.com/huonw/ieee754 - Low-level manipulations of IEEE754 floating-point numbers.
• [2019-11-25][Active] https://github.com/huonw/hamming - Compute the Hamming weight of a vector and the Hamming distance between two efficiently http://huonw.github.io/hamming/hamming
• [2020-01-13][Active] https://github.com/blas-lapack-rs/blas-src - BLAS(Basic Linear Algebra Subprograms基本线性计算) source of choice (https://github.com/blas-lapack-rs/blas-lapack-rs.github.io/wiki).
• [2020-01-13][Active] https://github.com/blas-lapack-rs/openblas-src - Source of BLAS and LAPACK via OpenBLAS (https://blas-lapack-rs.github.io/usage).
• [2020-04-17][Active] https://github.com/ritchie46/lsh-rs - Locality Sensitivy Hashing (LSH)

Data, Data opt/etl or Database/Datawarehouse opt relatives

• [2019-10-18][Active] https://github.com/pingcap/rust-prometheus
• [2019-10-18][Died] https://github.com/nickel-org/nickel-postgres
• [2019-10-18][Died] https://github.com/sfackler/r2d2-postgres - A generic connection pool for Rust.
• [2019-10-18][Active] https://github.com/sfackler/rust-postgres - postgres db driver.
• [2019-10-18][Active] https://github.com/sfackler/rust-postgres-large-object
• [2019-10-19][Active] https://github.com/sfackler/foreign-types
• [2019-10-22][Active] https://github.com/rust-rocksdb/rust-rocksdb - rust wrapper for rocksdb.
• [2019-10-23][Active] https://github.com/diesel-rs/diesel - ORM. A safe, extensible ORM and Query Builder for Rust http://diesel.rs
• [2019-10-23][Active] https://github.com/graphql-rust/juniper - GraphQL server library for Rust. Juniper makes it possible to write GraphQL servers in Rust that are type-safe and blazingly fast. We also try to make declaring and resolving GraphQL schemas as convenient as possible as Rust will allow.
• [2019-10-23][Active] https://github.com/sfackler/rust-phf - Compile time static maps for Rust with CHD algorithm.
• [2019-10-25][Active] https://github.com/steffengy/tiberius - TDS 7.4 (mssql / Microsoft SQL Server) async driver for rust.
• [2019-10-25][Active] https://github.com/That3Percent/soa-vec - Soa2, Soa3, ..SoaN are generic collections with an API similar to that of a Vec of tuples but which store the data laid out as a separate slice per field. The advantage of this layout is that when iterating over the data only a subset need be loaded from RAM. This approach is common to game engines, and entity component systems in particular but is applicable anywhere that cache coherency and memory bandwidth are important for performance.
• [2019-10-25][Active] https://github.com/tantivy-search/tantivy - Tantivy is a full-text search engine library inspired by Apache Lucene and written in Rust. It is closer to Apache Lucene than to Elasticsearch or Apache Solr in the sense it is not an off-the-shelf search engine server, but rather a crate that can be used to build such a search engine.
• [2019-10-27][Active] https://github.com/tantivy-search/tantivy-cli - tantivy-cli is the project hosting the command line interface for tantivy, a search engine project.
• [2019-10-25][Active] https://github.com/BurntSushi/fst - This crate provides a fast implementation of ordered sets and maps using finite state machines. In particular, it makes use of finite state transducers to map keys to values as the machine is executed. Using finite state machines as data structures enables us to store keys in a compact format that is also easily searchable. For example, this crate leverages memory maps to make range queries very fast.
• [2019-10-27][Active] https://github.com/TimelyDataflow/timely-dataflow - Timely dataflow is a low-latency cyclic dataflow computational model, introduced in the paper Naiad: a timely dataflow system. This project is an extended and more modular implementation of timely dataflow in Rust.
• [2019-10-28][Active] https://github.com/RedBeardLab/rediSQL - RediSQL is the Fast, in-memory, SQL engine with batteries included. it is based on Redis, supports all the persistency features of Redis. Also supports Python, go, Nodejs.
• [2019-10-28][Active] https://github.com/bodil/im-rs - Blazing fast immutable collection datatypes for Rust. Comes in two versions: im (thread safe) and im-rc (fast but not thread safe).
• [2019-10-28][Active] https://github.com/petgraph/petgraph - Graph data structure library for Rust
• [2019-10-28][Active] https://github.com/Xudong-Huang/may_postgres - postgres client for rust stackful coroutine
• [2019-10-29][Active] https://github.com/sfackler/r2d2 - A generic connection pool for Rust. Opening a new database connection every time one is needed is both inefficient and can lead to resource exhaustion under high traffic conditions. A connection pool maintains a set of open connections to a database, handing them out for repeated use. r2d2 is agnostic to the connection type it is managing. Implementors of the ManageConnection trait provide the database-specific logic to create and check the health of connections.
• [2019-10-29][Active] https://github.com/jgallagher/rusqlite - Ergonomic bindings to SQLite for Rust.
• [2019-10-29][Active] https://github.com/apache/arrow/tree/master/rust/datafusion - DataFusion is an in-memory query engine that uses Apache Arrow as the memory model. It supports executing SQL queries against CSV and Parquet files as well as querying directly against in-memory data. ref: https://andygrove.io/how_to_build_a_modern_distributed_compute_platform/.
• [2019-10-29][Active] https://github.com/apache/arrow/tree/master/rust/parquet - An Apache Parquet implementation in Rust.
• [2019-10-29][Active] https://github.com/aldanor/hdf5-rust - The hdf5 crate (previously known as hdf5-rs) provides thread-safe Rust bindings and high-level wrappers for the HDF5 library API.
• [2019-10-29][Active] https://github.com/apache/arrow/tree/master/rust - The Rust implementation of Arrow consists of the following crates.
• [2019-10-29][Active] https://github.com/apache/arrow - Apache Arrow is a cross-language development platform for in-memory data. It specifies a standardized language-independent columnar memory format for flat and hierarchical data, organized for efficient analytic operations on modern hardware. It also provides computational libraries and zero-copy streaming messaging and interprocess communication… https://arrow.apache.org
• [2019-10-29][Active] https://github.com/andygrove/ballista - PoC of distributed compute platform using Rust, Apache Arrow, and Kubernetes! I originally wanted DataFusion to be a distributed compute platform but this was overly ambitious at the time, and it ended up becoming an in-memory single-threaded query execution engine for the Rust implementation of Apache Arrow. However, DataFusion now provides a good foundation to have another attempt at building a modern distributed compute platform in Rust. My goal is to use this repo to move fast and try out ideas that help drive requirements for Apache Arrow and DataFusion.
• [2019-10-29][Active] https://github.com/andygrove/sqlparser-rs - The goal of this project is to build a SQL lexer and parser capable of parsing SQL that conforms with the ANSI/ISO SQL standard while also making it easy to support custom dialects so that this crate can be used as a foundation for vendor-specific parsers. This parser is currently being used by the DataFusion query engine and LocustDB.
• [2019-10-29][Active] https://github.com/cswinter/LocustDB - Massively parallel, high performance analytics database that will rapidly devour all of your data.
• [2019-10-29][Active] https://github.com/indradb/indradb - A graph database written in rust. IndraDB consists of a server and an underlying library. Most users would use the server, which is available via releases as pre-compiled binaries. But if you're a rust developer that wants to embed a graph database directly in your application, you can use the library. ref: https://github.com/indradb/python-client.
• [2019-10-30][Active] https://github.com/tikv/rust-prometheus - This is the Rust client library for Prometheus. The main Structures and APIs are ported from Go client.
• [2019-10-30][Active] https://github.com/erickt/rust-zmq - The zmq crate provides bindings for the libzmq library from the ZeroMQ project. The API exposed by zmq should be safe (in the usual Rust sense), but it follows the C API closely, so it is not very idiomatic. Also, support for libzmq API in "draft" state is considered out-of-scope for this crate; this includes currently, as of libzmq 4.3.3: Newer, thread-safe socket types, such as ZMQ_CLIENT and ZMQ_SERVER; The "poller" API. For a more modern, idiomatic approach to libzmq bindings, including draft API features, have a look at libzmq-rs(https://github.com/jean-airoldie/libzmq-rs).
• [2020-01-13][Died] https://github.com/kernelmachine/utah - Dataframe structure and operations in Rust. Utah is a Rust crate backed by ndarray for type-conscious, tabular data manipulation with an expressive, functional interface. Note: This crate works on stable. However, if you are working with dataframes with f64 data, use nightly, because you will get the performance benefits of specialization.
• [2020-01-13][Active] https://github.com/rajasekarv/native_spark - A new, arguably faster, implementation of Apache Spark from scratch in Rust. WIP. Framework tested only on Linux, requires nightly Rust. Read how to get started in the documentation (https://rajasekarv.github.io/native_spark/chapter_1.html).

Data Format relative

• [2019-10-19][Active] https://github.com/serde-rs/serde - Serde is a framework for serializing and deserializing Rust data structures efficiently and generically.
• [2019-11-25][Active] https://github.com/BurntSushi/rust-csv - A fast and flexible CSV reader and writer for Rust, with support for Serde. ref: https://docs.rs/csv/1.0.0/csv/tutorial/index.html.
• [2019-10-29][Active] https://github.com/J-F-Liu/lopdf - A Rust library for PDF document manipulation.
• [2019-10-29][Active] https://github.com/J-F-Liu/pom - PEG stands for parsing expression grammar, is a type of analytic formal grammar, i.e. it describes a formal language in terms of a set of rules for recognizing strings in the language. Unlike CFGs, PEGs cannot be ambiguous; if a string parses, it has exactly one valid parse tree. It could do the same thing like regex. Parsing xml/json/yaml/toml like dom, programming language code, or other structured docs. ref: https://bodil.lol/parser-combinators/

ML-DL

• [2019-11-03][Active] https://github.com/weld-project/weld - High-performance runtime for data analytics applications https://www.weld.rs
• [2019-10-20][Active] https://github.com/RustAudio/deepspeech-rs - The library is open source and performs Speech-To-Text completely offline. They provide pretrained models for English. It binds to https://github.com/mozilla/DeepSpeech.
• [2019-10-22][Died] https://github.com/AtheMathmo/rusty-machine -Rusty-machine is a general purpose machine learning library implemented entirely in Rust. It aims to combine speed and ease of use - without requiring a huge number of external dependencies.
• [2019-10-22][Died] https://github.com/AtheMathmo/rulinalg - Rulinalg is a linear algebra library written in Rust that doesn't require heavy external dependencies. The goal of rulinalg is to provide efficient implementations of common linear algebra techniques in Rust.
• [2020-01-13][Activie] https://github.com/AtheMathmo/rugrads - A proof of concept automatic differentiation library for Rust. This project began as a way for me to learn Rust and brush up on some less familiar machine learning algorithms and techniques. Now the project aims to provide a complete, easy to use, machine learning library for Rust. This library is still very much in early stages of development. Although there are a good number of algorithms many other things are missing. Rusty-machine is probably not the best choice for any serious projects - but hopefully that can change in the near future!
• [2019-10-22][Died] https://github.com/AtheMathmo/vision-rs - Access to computer vision benchmarking datasets in Rust. This library provides access to common machine learning benchmarking datasets.
• [2019-10-22][Active] https://github.com/arrayfire/arrayfire-rust - ArrayFire is a high performance library for parallel computing with an easy-to-use API. It enables users to write scientific computing code that is portable across CUDA, OpenCL and CPU devices. This project provides Rust bindings for the ArrayFire library. https://github.com/arrayfire/arrayfire: ArrayFire: a general purpose GPU library.
• [2019-10-22][Died] https://github.com/autumnai/leaf - Open Machine Intelligence Framework for Hackers. (GPU/CPU)
• [2019-10-22][Died] https://github.com/jackm321/RustNN - RustNN is a feedforward neural network library. The library generates fully connected multi-layer artificial neural networks that are trained via backpropagation. Networks are trained using an incremental training mode.
• [2019-10-22][Died] https://github.com/jackm321/Rust_Classifier - A naive Bayes classifier crate for Rust
• [2019-10-22][Died] https://github.com/japaric-archived/nvptx - How to: Run Rust code on your NVIDIA GPU
• [2019-10-23][Active] https://github.com/bheisler/RustaCUDA - RustaCUDA helps you bring GPU-acceleration to your projects by providing a flexible, easy-to-use interface to the CUDA GPU computing toolkit. RustaCUDA makes it easy to manage GPU memory, transfer data to and from the GPU, and load and launch compute kernels written in any language.
• [2019-10-23][Active] https://github.com/YunYang1994/ai-notebooks - reimplements articles code with tensorflow.
• [2019-10-25][Active] https://github.com/jJimo/rust-bloomfilter - A bloom filter implementation in Rust, using mixing hash function and XXHASH （https://github.com/Cyan4973/xxHash）
• [2019-10-28][Active] https://github.com/calebwin/emu - Emu is a framework/compiler for GPU acceleration of Rust, GPU programming. It is a procedural macro that accept pure, safe Rust code as input, identifies portions to attempt to accelerate, and automatically writes in code to run portions on the GPU instead of the CPU.
• [2019-10-28][Active] https://github.com/jwilm/alacritty - A cross-platform, GPU-accelerated terminal emulator. Alacritty is the fastest terminal emulator in existence. Using the GPU for rendering enables optimizations that simply aren't possible without it. Alacritty currently supports macOS, Linux, BSD, and Windows.
• [2019-10-29][Active] https://github.com/spearow/juice - The Hacker's Machine Learning Engine (formerly known as leaf). This is the workspace projet for: juice(https://github.com/spearow/juice/blob/master/juice/README.md) - machine learning frameworks for hackers; coaster(https://github.com/spearow/juice/blob/master/coaster/README.md) - underlying math abstraction; coaster-nn(https://github.com/spearow/juice/blob/master/coaster-nn/README.md); coaster-blas(https://github.com/spearow/juice/blob/master/coaster-blas/README.md); greenglas (https://github.com/spearow/juice/blob/master/greenglas/README.md) - a data preprocessing framework; juice-examples(https://github.com/spearow/juice/blob/master/juice-examples/README.md) - mnist demo.
• [2019-11-25][Died] https://github.com/daniel-e/rustml - Machine learning in Rust.
• [2020-01-12][Died] https://github.com/maciejkula/rustlearn - Machine learning crate for Rust. For full usage details, see the API documentation(https://maciejkula.github.io/rustlearn/doc/rustlearn/).
• [2020-01-12][Died] https://github.com/Entscheider/stamm - Stamm is a rust library for creating decision trees and random forests in a very general way. Decision trees are used in machine learning for classification and regression. A random forest bundles some decision trees for making a more precise classification or regression.
• [2020-01-13][Died] https://github.com/kernelmachine/rust-linear-algebra - rust linear algebra.
• [2020-01-13][Died] https://github.com/kernelmachine/rsml - machine learning algorithms in rust.
• [2020-01-13][Died] https://github.com/maciejkula/wyrm - Autodifferentiation package in Rust. Performs backpropagation through arbitrary, define-by-run computation graphs, emphasizing low overhead estimation of sparse, small models on the CPU. Highlights: Low overhead; Built-in support for sparse gradients; Define-by-run; Trivial Hogwild-style parallelisation, scaling linearly with the number of CPU cores available.
• [2020-01-13][Active] https://github.com/maciejkula/sbr-rs - Deep recommender systems for Rust(LSTM, EWMA). An implementation of sequence recommenders based on the wyrm autdifferentiaton library.
• [2020-01-13][Active] https://github.com/blas-lapack-rs/blas-src - BLAS(Basic Linear Algebra Subprograms基本线性计算) source of choice (https://github.com/blas-lapack-rs/blas-lapack-rs.github.io/wiki).
• [2020-01-13][Active] https://github.com/blas-lapack-rs/openblas-src - Source of BLAS and LAPACK via OpenBLAS (https://blas-lapack-rs.github.io/usage).

InterActive with Other Programming-Language/Platform

• [2019-10-18][Active] https://github.com/RustPython/RustPython - Looks good to me
• [2019-11-25][Active] https://github.com/alexcrichton/cc-rs - Compile c/c++ code to binary and call by Rust. https://docs.rs/cc
• [2019-10-19][Active] https://github.com/eqrion/cbindgen - A project for generating C bindings from Rust code.
• [2019-10-22][Active] https://github.com/rust-lang/libc - Raw bindings to platform APIs for Rust. libc provides all of the definitions necessary to easily interoperate with C code (or "C-like" code) on each of the platforms that Rust supports. This includes type definitions (e.g. c_int), constants (e.g. EINVAL) as well as function headers (e.g. malloc).
• [2019-10-23][Active] https://github.com/dgrunwald/rust-cpython - Rust bindings for the python interpreter.
• [2019-10-25][Died] https://github.com/blas-lapack-rs/lapack-sys - Bindings to LAPACK (Fortran)
• [2019-10-25][Active] https://github.com/indygreg/PyOxidizer - PyOxidizer is a utility for producing binaries that embed Python. The over-arching goal of PyOxidizer is to make complex packaging and distribution problems simple so application maintainers can focus on building applications instead of toiling with build systems and packaging tools.
• [2019-10-25][Active] https://github.com/yorkie/rust.js - Run your JavaScript apps backed by Rust. The platform lets you can work with Rust, C, C++ and JavaScript compatible with NPM and Cargo
• [2019-10-25][Active] https://github.com/google/rustcxx - rustcxx is a tool allowing C++ to be used from a Rust project easily. It works by allowing snippets of C++ to be included within a Rust function, and vice-versa.
• [2019-10-25][Active] https://github.com/mystor/rust-cpp - Embed C++ directly inside your rust code!
• [2019-10-25][Active] https://github.com/darfink/chakracore-rs#chakracore-sys - This library handles the static and dynamic linking of the JavaScript Runtime. The rust bindings are generated (on the fly) for the interface, therefore the entire API is exposed and accessable.
• [2019-10-27][Active] https://github.com/That3Percent/js-object - A macro for creating JavaScript objects.
• [2019-10-28][Active] https://github.com/PistonDevelopers/dyon - A rusty dynamically typed scripting language. Sven Nilsen started this project in early 2016. The idea was to make a simple, but convenient scripting language that integrated well with Rust.
• [2019-10-28][Active] https://github.com/immunant/c2rust - C2Rust helps you migrate C99-compliant code to Rust. The translator (or transpiler) produces unsafe Rust code that closely mirrors the input C code. The primary goal of the translator is to preserve functionality; test suites should continue to pass after translation. Generating safe and idiomatic Rust code from C ultimately requires manual effort. However, we are building a scriptable refactoring tool that reduces the tedium of doing so. You can also cross-check the translated code against the original (tutorial).
• [2019-10-28][Active] https://github.com/d-unseductable/ruru - Native Ruby extensions written in Rust.
• [2019-10-29][Active] https://github.com/eqrion/cbindgen - A project for generating C bindings from Rust code
• [2019-10-29][Active] https://github.com/KDE/rust-qt-binding-generator - Generate bindings to use Rust code in Qt and QML. This code generator gets you started quickly to use Rust code from Qt and QML. In other words, it helps to create a Qt based GUI on top of Rust code. Qt is a mature cross-platform graphical user interface library. Rust is a new programming language with strong compile time checks and a modern syntax.
• [2019-10-29][Active] https://github.com/capnproto/capnproto-rust - Cap'n Proto is a type system for distributed systems. You can then use the capnp tool to generate code in a variety of programming languages. The generated code lets you produce and consume values of the types you've defined in your schema. Values are encoded in a format that is suitable not only for transmission over a network and persistence to disk, but also for zero-copy in-memory traversal. That is, you can completely skip serialization and deserialization! It's in this sense that Cap'n Proto is "infinity times faster" than alternatives like Protocol Buffers.
• [2019-11-22][Active] https://github.com/TheDan64/inkwell - It's a New Kind of Wrapper for Exposing LLVM (Safely) https://thedan64.github.io/inkwell/
• [2019-11-25][Dicd] https://github.com/huonw/python_mixin - python_mixin, Run Python code to make your Rust code, in your Rust code. Probably not, this is mainly me experimenting with more language plugins. A more portable/usable way to do this sort of code-generation is via a Cargo build script plus the include! macro.
• [2020-02-24][Active] https://github.com/finalfusion/finalfusion-rust/ - finalfusion is a crate for reading, writing, and using embeddings in Rust. finalfusion primarily works with its own format which supports a large variety of features. Additionally, the fastText, word2vec and GloVe file formats are also supported.

Middleware relatives

• [2019-10-18][Active] https://github.com/pingcap/raft-rs - A distributed consensus algorithm implemented in Rust.
• [2019-10-18][Active] https://github.com/crossbeam-rs/crossbeam - Tools for concurrent programming in Rust, RPC, PIPE, SYNC and etc.
• [2019-10-25][Active] https://github.com/jean-airoldie/libzmq-rs - This crate builds and generates bindings from source. This means that you do not need to install libzmq. we will only use a subset of libzmq. If you'd rather have a complete port, check out rust-zmq. (https://github.com/erickt/rust-zmq)
• [2019-11-25][Active] https://github.com/erickt/rust-zmq - The zmq crate provides bindings for the libzmq library from the ZeroMQ project. The API exposed by zmq should be safe (in the usual Rust sense), but it follows the C API closely, so it is not very idiomatic. Also, support for libzmq API in "draft" state is considered out-of-scope for this crate; this includes currently, as of libzmq 4.3.3
• [2019-10-29][Active] https://github.com/oam-dev/rudr - Rudr (https://github.com/oam-dev/spec) is an implementation of the Open Application Model (OAM,https://openappmodel.io/) that allow users to deploy and manage applications easily on any Kubernetes cluster with separation of concerns of application developer and operator. sponsored by MS and Alibaba group.

Networking

• [2019-10-18][Active] https://github.com/sfackler/rust-socks
• [2019-10-18][Active] https://github.com/alexcrichton/socket2-rs
• [2019-10-22][Active] https://github.com/stepancheg/rust-protobuf - Rust implementation of Google protocol buffers.
• [2019-10-18][Active] https://github.com/cloudflare/boringtun a replacement of OpenVPN
• [2019-10-18][Active] https://github.com/hyperium/http - A general purpose library of common HTTP types.
• [2019-10-19][Active] https://github.com/paritytech/jsonrpc
• [2019-10-22][Active] https://github.com/seanmonstar/reqwest - An ergonomic, batteries-included HTTP Client for Rust. Base on hyper crate.
• [2019-10-22][Active] https://github.com/hyperium/hyper - An HTTP library for Rust https://hyper.rs. Hyper is a relatively low-level library, if you are looking for simple high-level HTTP client, then you may wish to consider reqwest, which is built on top of this library.
• [2019-10-22][Active] https://github.com/hyperium/tonic - A native gRPC client & server implementation with async/await support. https://docs.rs/tonic.
• [2019-10-22][Active] https://github.com/hyperium/h2 - The h2 library has implemented more of the details of the HTTP/2.0 specification than any other Rust library. It also passes the h2spec set of tests.
• [2019-10-22][Active] https://github.com/hyperium/hyper-tls - Provides an HTTPS connector for use with hyper.
• [2019-10-22][Active] https://github.com/hyperium/http-body - Asynchronous HTTP body trait.
• [2019-10-22][Active] https://github.com/hyperium/http-connection -
• [2019-10-22][Active] https://github.com/shadowsocks/shadowsocks-rust - This is a port of shadowsocks, which is VPN Client.
• [2019-10-22][Active] https://github.com/websockets-rs/rust-websocket - Rust-WebSocket is a WebSocket (RFC6455) library written in Rust.
• [2019-10-22][Active] https://github.com/tikv/grpc-rs - The gRPC library for Rust built on C Core library and futures.
• [2019-10-22][Active] https://github.com/stepancheg/grpc-rust -
• [2019-10-22][Active] https://github.com/servo/rust-url -
• [2019-10-23][Active] https://github.com/libp2p/rust-libp2p - Rust Implementation of libp2p networking stack. https://libp2p.io Modular peer-to-peer networking stack (used by IPFS and others)
• [2019-10-25][Active] https://github.com/kardeiz/jsonrpc-v2 - JSON-RPC 2.0 server-focused framework. Provides integrations for both hyper and actix-web. Enable features actix or hyper depending on need.
• [2019-10-25][Active] https://github.com/abonander/multipart-async - Futures-based client- and server-side abstractions for HTTP file uploads (POST requests with Content-Type: multipart/form-data). Preliminary support for Hyper 0.13 and async/await; requires 1.39 to build (nightly-2019-08-15, will be released to beta on 2019-09-26)
• [2019-10-25][Active] https://github.com/google/tarpc - This is not an official Google product. tarpc is an RPC framework for rust with a focus on ease of use. Defining a service can be done in just a few lines of code, and most of the boilerplate of writing a server is taken care of for you.
• [2019-10-28][Active] https://github.com/djc/quinn - QUIC is an IETF Working Group that is chartered to deliver the next transport protocol for the Internet. Quinn is an implementation of the QUIC transport protocol undergoing standardization by the IETF. It is suitable for experimental use. The implementation is split up into the state machine crate quinn-proto which performs no I/O internally and is suitable for use with custom event loops, and a high-level tokio-compatible API in quinn. See quinn/examples/ for usage.
• [2019-10-28][Active] https://github.com/housleyjk/ws-rs Lightweight, event-driven WebSockets for Rust. This library provides an implementation of WebSockets, RFC6455 using MIO. It allows for handling multiple connections on a single thread, and even spawning new client connections on the same thread. This makes for very fast and resource efficient WebSockets. The API design abstracts away the menial parts of the WebSocket protocol and allows you to focus on application code without worrying about protocol conformance. However, it is also possible to get low-level access to individual WebSocket frames if you need to write extensions or want to optimize around the WebSocket protocol.
• [2019-10-28][Active] https://github.com/libpnet/libpnet - Cross-platform, low level networking using the Rust.
• [2019-10-28][Active] https://github.com/tower-rs/tower - fn(Request) -> Future. Tower aims to make it as easy as possible to build robust networking clients and servers. It is protocol agnostic, but is designed around a request / response pattern. If your protocol is entirely stream based, Tower may not be a good fit. https://github.com/notify-rs/notify - Cross-platform filesystem notification library for Rust(Looking for desktop notifications instead? Have a look at notify-rust or alert-after). As used by: alacritty, cargo watch, cobalt, docket, mdBook, pax rdiff, rust-analyzer, timetrack, watchexec, xi-editor, and others.

Network Spider

• [2019-10-29][Died] https://github.com/derniercri/snatch - A simple, fast and interruptable download accelerator, written in Rust.
• [2019-10-29][Active] https://github.com/k0pernicus/zou - Zou is a Snatch fork by @k0pernicus. Snatch is a fast and interruptable download accelerator, written in Rust, from @k0pernicus and @Jean-Serge.

Serialization

• [2019-10-23][Active] https://github.com/BurntSushi/byteorder - Rust library for reading/writing numbers in big-endian and little-endian.
• [2020-01-12][Active] https://github.com/serde-rs/serde - Serde is a framework for serializing and deserializing Rust data structures efficiently and generically.
• [2019-10-20][Active] https://github.com/dtolnay/typetag - Serde serializable and deserializable trait objects .
• [2019-10-22][Active] https://github.com/stepancheg/rust-protobuf - Rust implementation of Google protocol buffers. Base on https://github.com/carllerche/bytes.
• [2019-10-22][Active] https://github.com/tafia/quick-protobuf -
• [2019-10-22][Active] https://github.com/danburkert/prost -
• [2019-10-22][Active] https://github.com/dflemstr/serde-protobuf -
• [2019-10-23][Active] https://github.com/google/flatbuffers - FlatBuffers is a cross platform serialization library architected for maximum memory efficiency. It allows you to directly access serialized data without parsing/unpacking it first, while still having great forwards/backwards compatibility.
• [2019-10-23][Active] https://github.com/mvdnes/zip-rs - Zip implementation in Rust.
• [2019-10-23][Active] https://github.com/ron-rs/ron - RON is a simple readable data serialization format that looks similar to Rust syntax. It's designed to support all of Serde's data model(https://serde.rs/data-model.html), so structs, enums, tuples, arrays, generic maps, and primitive values.
• [2019-10-28][Active] https://github.com/servo/bincode - A binary encoder / decoder implementation in Rust. A compact encoder / decoder pair that uses a binary zero-fluff encoding scheme. The size of the encoded object will be the same or smaller than the size that the object takes up in memory in a running Rust program. In addition to exposing two simple functions (one that encodes to Vec, and one that decodes from &[u8]), binary-encode exposes a Reader/Writer API that makes it work perfectly with other stream-based APIs such as Rust files, network streams, and the flate2-rs compression library.
• [2019-10-29][Active] https://github.com/pikkr/pikkr - JSON parser which picks up values directly without performing tokenization in Rust. This JSON parser is implemented based on Y. Li, N. R. Katsipoulakis, B. Chandramouli, J. Goldstein, and D. Kossmann. Mison: a fast JSON parser for data analytics. In VLDB, 2017(http://www.vldb.org/pvldb/vol10/p1118-li.pdf).
• [2019-10-29][Active] https://github.com/orium/rpds - Rust Persistent Data Structures. Rust Persistent Data Structures provides fully persistent data structures(https://en.wikipedia.org/wiki/Persistent_data_structure) with structural sharing. This crate offers the following data structures: List; Vector; Stack; Queue; HashTrieMap; HashTrieSet; RedBlackTreeMap; RedBlackTreeSet.
• [2019-10-29][Active] https://github.com/capnproto/capnproto-rust - Cap'n Proto is a type system for distributed systems. You can then use the capnp tool to generate code in a variety of programming languages. The generated code lets you produce and consume values of the types you've defined in your schema. Values are encoded in a format(https://capnproto.org/encoding.html) that is suitable not only for transmission over a network and persistence to disk, but also for zero-copy in-memory traversal. That is, you can completely skip serialization and deserialization! It's in this sense that Cap'n Proto is "infinity times faster" than alternatives like Protocol Buffers.

Crypto

• [2019-10-18][Active] https://github.com/sfackler/rust-openssl - OpenSSL bindings for Rust.
• [2019-10-18][Active] https://github.com/sfackler/hyper-native-tls - An abstraction over platform-specific TLS implementations.
• [2019-10-22][Active] https://github.com/ctz/rustls - Rustls is a TLS library that aims to provide a good level of cryptographic security, requires no configuration to achieve that security, and provides no unsafe features or obsolete cryptography.
• [2019-10-22][Died] https://github.com/DaGenix/rust-crypto - A (mostly) pure-Rust implementation of various cryptographic algorithms. ust-Crypto seeks to create practical, auditable, pure-Rust implementations of common cryptographic algorithms with a minimum amount of assembly code where appropriate. The x86-64, x86, and ARM architectures are supported, although the x86-64 architecture receives the most testing.
• [2019-10-23][Active] https://github.com/jedisct1/libhydrogen - A lightweight, secure, easy-to-use crypto library suitable for constrained environments. https://libhydrogen.org
• [2019-10-23][Active] https://github.com/sodiumoxide/sodiumoxide - Sodium is a portable, cross-compilable, installable, packageable fork of NaCl (based on the latest released upstream version nacl-20110221), with a compatible API. Sodium Oxide: Fast cryptographic library for Rust (bindings to libsodium)
• [2019-10-23][Died] https://github.com/dcuddeback/des_crack
• [2019-10-26][Active] https://github.com/sekey/sekey - Use Touch ID / Secure Enclave for SSH Authentication!
• [2019-10-27][Active] https://github.com/mesalock-linux/mesalink - MesaLink is a memory-safe and OpenSSL-compatible TLS library. MesaLink has been in production at Baidu with >10 million monthly active users. website: https://mesalink.io.
• [2019-10-28][Active] https://github.com/nayuki/QR-Code-generator - This project aims to be the best, clearest QR Code generator library in multiple languages. The primary goals are flexible options and absolute correctness. Secondary goals are compact implementation size and good documentation comments.
• [2020-01-09][active] https://github.com/apache/incubator-teaclave-sgx-sdk - Rust SGX SDK provides the ability to write Intel SGX applications. Software Guard Extensions (Intel® SGX)保护选定的代码和数据不被泄露和修改。

Server (WEB, middle layer, microserive, serverless and etc.)

• [2019-10-18][Active] https://github.com/nickel-org/nickel.rs
• [2019-10-22][Active] https://github.com/SergioBenitez/Rocket - Rocket is a web framework for Rust (nightly) with a focus on ease-of-use, expressibility, and speed.
• [2019-10-22][Active] https://github.com/websockets-rs/rust-websocket - Rust-WebSocket is a WebSocket (RFC6455) library written in Rust. Rust-WebSocket provides a framework for dealing with WebSocket connections (both clients and servers). The library is currently in an experimental state, but provides functionality for both normal and secure WebSockets, a message level API supporting fragmentation, a data frame level API, and the ability to extend and customize behaviour.
• [2019-11-25][Active] https://github.com/iron/iron - An Extensible, Concurrent Web Framework for Rust http://ironframework.io
• [2019-10-23][Died] https://github.com/rustless/rustless - REST-like API micro-framework for Rust. Works with Iron.
• [2019-10-23][Active] https://github.com/flosse/rust-web-framework-comparison - A comparison of some web frameworks and libs written in Rust.
• [2019-10-23][Active] https://github.com/servo/rust-mozjs - Rust bindings to SpiderMonkey, which is the code name for the first JavaScript engine, written by Brendan Eich at Netscape Communications, later released as open-source and currently maintained by the Mozilla Foundation.
• [2019-10-25][Active] https://github.com/kardeiz/reset-router - A fast RegexSet based router for use with async Hyper (0.12).
• [2019-10-25][Active] https://github.com/mit-pdos/noria - Noria is a new streaming data-flow system designed to act as a fast storage backend for read-heavy web applications based on this paper from OSDI'18. It acts like a database, but precomputes and caches relational query results so that reads are blazingly fast. Noria automatically keeps cached results up-to-date as the underlying data, stored in persistent base tables, change. Noria uses partially-stateful data-flow to reduce memory overhead, and supports dynamic, runtime data-flow and query change.
• [2019-10-25][Active] https://github.com/tailhook/vagga - Vagga is a fully-userspace container engine inspired by Vagrant and Docker, specialized for development environments.Runs containerized process as a child of current shell, no attach/detach hell;Images are automatically rebuilt and versioned;Fully userspace containers, no need for elevated privileges like for Docker;Running programs in linux containers (not a full virtualization like Vagrant);manage trees of processes (so you run your redis-python-nginx server with one command);Compatibility with Vagrant-LXC and Docker_. ref: https://vagga.readthedocs.org/
• [2019-10-25][Active] https://github.com/Keats/tera - A template engine for Rust based on Jinja2/Django https://tera.netlify.com/
• [2019-10-25][Active] https://github.com/pepsighan/rust-web-developer-roadmap - Below you can find a chart demonstrating the path you may take and the libraries you may require to become a Rust Web Developer. This chart is made with inspiration from Golang Developer Roadmap(https://github.com/Alikhll/golang-developer-roadmap/).
• [2019-11-25][Active] https://github.com/nickel-org/nickel.rs - An expressjs inspired web framework for Rust http://nickel-org.github.io/. nickel.rs is a simple and lightweight foundation for web applications written in Rust. Its API is inspired by the popular express framework for JavaScript.
• [2019-10-27][Active] https://github.com/saschagrunert/webapp.rs - A web application completely written in Rust. https://medium.com/@saschagrunert/a-web-application-completely-in-rust-6f6bdb6c4471 and https://medium.com/@saschagrunert/lessons-learned-on-writing-web-applications-completely-in-rust-2080d0990287
• [2019-10-27][Active] https://github.com/saschagrunert/kubernix - Single dependency Kubernetes clusters for local testing, experimenting and development. This project aims to provide single dependency Kubernetes clusters for local testing, experimenting and development purposes.
• [2019-10-27][Active] https://awesomeopensource.com/project/djc/askama - Type-safe, compiled Jinja-like templates for Rust.
• [2019-10-28][Active] https://github.com/daogangtang/sapper - Sapper, a lightweight web framework, close to flask in python, written in Rust, relied on Hyper(https://github.com/hyperium/hyper). https://github.com/sappworks/sapper/blob/master/docs/Tutorial-cn.md
• [2019-10-28][Active] https://github.com/David-OConnor/seed - A Rust framework for creating web apps. https://seed-rs.org/ Engineering Rust Web Applications(https://erwabook.com/intro/)
• [2019-10-29][Active] https://github.com/valeriansaliou/vigil - Microservices Status Page. Monitors a distributed infrastructure and sends alerts (Slack, SMS, etc.). Vigil is an open-source Status Page you can host on your infrastructure, used to monitor all your servers and apps, and visible to your users (on a domain of your choice, eg. status.example.com). It is useful in microservices contexts to monitor both apps and backends. If a node goes down in your infrastructure, you receive a status change notification in a Slack channel, Email, Twilio SMS or/and XMPP. who use it? Crisp; Meili; miragespace; Redsmin; Image-Charts.
• [2019-10-29][Active] https://github.com/capnproto/capnproto-rust - Cap'n Proto is a type system for distributed systems. You can then use the capnp tool to generate code in a variety of programming languages. The generated code lets you produce and consume values of the types you've defined in your schema. Values are encoded in a format(https://capnproto.org/encoding.html) that is suitable not only for transmission over a network and persistence to disk, but also for zero-copy in-memory traversal. That is, you can completely skip serialization and deserialization! It's in this sense that Cap'n Proto is "infinity times faster" than alternatives like Protocol Buffers. * [2019-10-30][Active] https://github.com/capnproto/capnproto Cap'n Proto serialization/RPC system - core tools and C++ library.
• [2019-10-30][Active] https://github.com/capnproto/capnproto-rust - Cap'n Proto is a type system for distributed systems. It is like COM+ as MS defined. https://dwrensha.github.io/capnproto-rust
• [2019-11-20][Active] https://github.com/apache/openwhisk - open source serverless cloud platform, OpenWhisk - https://medium.com/the-theam-journey/hands-on-iot-applications-with-openwhisk-and-rust-acb9ef5bc166

GUI/Game relatives

• [2019-10-19][Active] https://github.com/gfx-rs/gfx - A low-overhead Vulkan-like GPU API for Rust.
• [2019-10-19][Active] https://github.com/amethyst/rendy - State of the art "build your own engine" kit powered by gfx-hal, which mimics the Vulkan API.
• [2019-10-19][Active] https://github.com/gfx-rs/wgpu - WebGPU native implementation in Rust.
• [2019-10-19][Active] https://github.com/brendanzab/gl-rs - An OpenGL function pointer loader for Rust.
• [2019-10-19][Active] https://github.com/kvark/vange-rs - The idea of this project is to replicate the old look and behavior, but with native hardware acceleration for the graphics.
• [2019-10-19][Active] https://github.com/rust-windowing/glutin - A low-level library for OpenGL context creation, written in pure Rust.
• [2019-10-19][Active] https://github.com/rust-windowing/winit - winit, Cross-platform window creation and management in Rust, like Qt.
• [2019-10-20][Active] https://github.com/rust-windowing/raw-window-handle - provides a common interface that window creation libraries (e.g. Winit, SDL) can use to easily talk with graphics libraries (e.g. gfx-hal).
• [2019-10-20][Died] https://github.com/oakes/SolidOak - SolidOak is a simple IDE for Rust
• [2019-10-23][Active] https://github.com/mvdnes/rboy - A Gameboy Emulator in Rust
• [2019-10-23][Active] https://github.com/rust-windowing/winit - Cross-platform window creation and management in Rust(js)
• [2019-10-23][Active] https://github.com/phaazon/luminance-rs - Type-safe, type-level and stateless Rust graphics framework. luminance provides an API that is, for sure, a bit less low-level — and hence, yes, it’s likely you will not have the same performances as with gfx-hal (even though no benchmarks have been done so far), and the API is not Vulkan-based — but easier to start with, especially if you don’t already have a background experience with OpenGL or Vulkan.
• [2019-10-28][Active] https://github.com/nical/lyon - 2D graphics rendering on the GPU in rust using path tessellation. For now the goal is to provide efficient SVG-compliant path tessellation tools to help with rendering vector graphics on the GPU. For now think of this library as a way to turn complex paths into triangles for use in your own rendering engine. The intent is for this library to be useful in projects like Servo and games.
• [2019-10-28][Active] https://github.com/flutter-rs/flutter-rs - Build beautiful desktop apps with flutter and rust. Support Hot reload;MethodChannel, EventChannel;Async runtime using tokio;ystem dialogs;Clipboard support;Cross platform support, Runs on mac, windows, linux;Support distribution format: (windows NSIS, mac app, mac dmg, linux snap).
• [2019-10-29][Active] https://github.com/GodotNativeTools/godot-rust - Rust bindings for GDNative. Godot provides a huge set of common tools, so you can just focus on making your game without reinventing the wheel. Godot is completely free and open-source under the very permissive MIT license. No strings attached, no royalties, nothing. Your game is yours, down to the last line of engine code.
• [2019-11-25][Active] https://github.com/gsingh93/ggp-rs - A library for creating GGP (general game playing) players in Rust
• [2019-11-25][Active] https://github.com/Twinklebear/tobj - A tiny OBJ loader, inspired by Syoyo's excellent tinyobjloader(https://github.com/syoyo/tinyobjloader - Tiny but powerful single file wavefront obj loader written in C++03. No dependency except for C++ STL. It can parse over 10M polygons with moderate memory and time.) Aims to be a simple and lightweight option for loading OBJ files, just returns two vecs containing loaded models and materials.

Web UI

• [2019-10-27][Active] https://github.com/ritz078/transform - A polyglot web converter. https://transform.tools
• [2019-11-25][Active] https://github.com/nickel-org/rust-mustache - A Logic-less templates inspired by ctemplate and et, Mustache is a framework-agnostic way to render logic-free views.

UI/Console tools

• [2019-10-18][Active] https://github.com/rust-lang-nursery/mdBook compile md via Rust.
• [2019-10-19][Active] https://github.com/lotabout/skim navigate files, lines, commands. It is a general fuzzy finder that saves you time.
• [2019-10-20][Active] https://github.com/integer32llc/rust-playground/ - This is the home of the Rust Playground(https://play.rust-lang.org/), also hosted by Integer 32(https://play.integer32.com/).
• [2019-10-25][Active] https://github.com/huytd/kanelm - Kanelm - Kanban Board in Elm.
• [2019-10-25][Died] https://github.com/huytd/kanban-app - This is a web-based Kanban board application, built with Elm and Rust. The only different from this application and hundred thousands of web-based application out there is: We don't need Electron!.
• [2019-10-25][Died] https://github.com/huytd/hackernews-rss-reader - Yet another HackerNews client. Live demo https://codedaily.xyz.
• [2019-10-25][Active] https://github.com/vadimcn/vscode-lldb - Native debugger extension for VSCode based on LLDB. Supports c++,rust and python.

Multi-media

• [2019-10-19][Active] https://github.com/jeremyletang/rust-sfml - A gent to Simple and Fast Multimedia Library(SFML) - https://www.sfml-dev.org/
• [2019-10-20][Active] https://github.com/RustAudio/rust-portaudio - PortAudio is a free, cross-platform, open-source, audio I/O library.
• [2019-10-20][Active] https://github.com/RustAudio/deepspeech-rs - The library is open source and performs Speech-To-Text completely offline. They provide pretrained models for English. It binds to https://github.com/mozilla/DeepSpeech.
• [2019-10-20][Active] https://github.com/RustAudio/rust-lv2 - A safe, fast, and ergonomic Rust library to create LV2 plugins for audio processing or synthesis, on any platform.
• [2019-10-20][Active] https://github.com/RustAudio/cpal - Cross-platform audio I/O library in pure Rust.
• [2019-10-20][Active] https://github.com/RustAudio/lewton - Vorbis decoder written in pure Rust.
• [2019-10-20][Active] https://github.com/RustAudio/coreaudio-rs - A friendly rust interface to Apple's Core Audio API.
• [2019-10-20][Active] https://github.com/meh/rust-ffmpeg - Safe FFmpeg wrapper.
• [2019-10-29][Active] https://github.com/pcwalton/rust-media - A free, comprehensive, and portable video/audio streaming library for Rust. rust-media is a media player framework for Rust, similar in spirit to libvlc or GStreamer. It's designed for use in Servo but is intended to be widely useful for all sorts of projects. Possible use cases are background music and FMVs for video games, as well as media player applications.
• [2019-10-29][Active] https://github.com/pcwalton/sprocketnes - sprocketnes is an emulator for the Nintendo Entertainment System written in the Rust programming language. Its purpose is to serve as a technology demonstration to show how the Rust programming language is suitable for systems software such as emulators. It has many shortcomings and is not intended to be a production-quality emulator. sprocketnes is also designed to be a relatively clean example codebase, showing off various Rust idioms.

Mobile device

• [2019-10-28][Active] https://github.com/rust-windowing/android-rs-glue - Glue between Rust and Android

Tools

• [2019-10-20][Active] https://github.com/servo/servo - The Servo Browser Engine https://servo.org/ Servo is a prototype web browser engine written in the Rust language. It is currently developed on 64-bit macOS, 64-bit Linux, 64-bit Windows, and Android.
• [2019-10-22][Active] https://github.com/racer-rust/racer - Rust Code Completion utility.
• [2019-10-22][Active] https://github.com/xi-editor/xi-editor - an Editor by Rust.
• [2019-11-25][Active] https://github.com/clap-rs/clap - A full featured, fast Command Line Argument Parser for Rust https://clap.rs.
• [2019-10-28][Active] https://github.com/redox-os/termion - Termion is a pure Rust, bindless library for low-level handling, manipulating and reading information about terminals. This provides a full-featured alternative to Termbox. ref: https://github.com/nsf/termbox-go Termbox is a library that provides a minimalistic API which allows the programmer to write text-based user interfaces. The library is crossplatform and has both terminal-based implementations on *nix operating systems and a winapi console based implementation for windows operating systems. The basic idea is an abstraction of the greatest common subset of features available on all major terminals and other terminal-like APIs in a minimalistic fashion. Small API means it is easy to implement, test, maintain and learn it, that's what makes the termbox a distinct library in its area.
• [2019-10-28][Active] https://github.com/rust-analyzer/rust-analyzer - An experimental Rust compiler front-end for IDEs.
• [2019-10-28][Active] https://github.com/dtolnay/syn - Parser for Rust source code. As development helper? Debug helper?
• [2019-10-29][Active] https://github.com/alexcrichton/curl-rust - Rust bindings to libcurl
• [2019-11-20][Active] https://github.com/servo/ - The Servo Browser

IoT

• [2019-10-23][Active] https://github.com/dcuddeback/termios-rs - The termios crate provides safe bindings for the Rust programming language to the terminal I/O interface implemented by Unix operating systems.
• [2019-10-23][Active] https://github.com/dcuddeback/libusb-rs - This crate provides a safe wrapper around the native libusb library. It applies the RAII pattern and Rust lifetimes to ensure safe usage of all libusb functionality. All systems supported by the native libusb library are also supported by the libusb crate. It's been tested on Linux, OS X, and Windows.
• [2019-10-23][Active] https://github.com/dcuddeback/libusb-sys - the libusb-sys crate provides declarations and linkage for the libusb C library. Following the *-sys package conventions, the libusb-sys crate does not define higher-level abstractions over the native libusb library functions.
• [2019-10-28][Active] https://github.com/rust-windowing/android-rs-glue - Glue between Rust and Android.
• [2019-10-29][Active] https://github.com/kennytm/rust-ios-android - Example project for building a library for iOS + Android in Rust. ref: https://github.com/Geal/rust_on_mobile
• [2019-10-30][Active] https://github.com/rust-embedded/itm - A Rust crate and tool itmdump to parse and dump ARM ITM packets(Instrumentation Trace Macrocell, arm log).
• [2019-10-30][Active] https://github.com/rust-embedded/gpio-cdev - rust-gpio-cdev is a Rust library/crate providing access to GPIO character device ABI. This API, stabilized with Linux v4.4, deprecates the legacy sysfs interface to GPIOs that is planned to be removed from the upstream kernel after year 2020 (which is coming up quickly). Use of this API is encouraged over the sysfs API used by this crate's predecessor sysfs_gpio if you don't need to target older kernels. For more information on differences see Sysfs GPIO vs GPIO Character Device.
• [2019-10-30][Active] https://github.com/rust-embedded/gpio-utils - GPIO Utils provides convenient access to GPIOs on a Linux system. The library builds on top of the sysfs interface to GPIOs exposed by the kernel and provides essential functionality required for most embedded systems.
• [2019-10-30][Active] https://github.com/rust-embedded/rust-i2cdev - The Rust i2cdev crate seeks to provide full access to the Linux i2cdev driver interface in Rust without the need to wrap any C code or directly make low-level system calls. The documentation for the i2cdev interace can be found at https://www.kernel.org/doc/Documentation/i2c/dev-interface and in the lm-sensors projects.
• [2019-10-30][Active] https://github.com/rust-embedded/linux-embedded-hal - Implementation of the embedded-hal(https://crates.io/crates/embedded-hal) traits for Linux devices.
• [2019-10-30][Active] https://github.com/rust-embedded/rust-spidev - The Rust spidev seeks to provide full access to the Linux spidev device in Rust without the need to wrap any C code or directly make low-level system calls. The documentation for the spidev interace can be found at https://www.kernel.org/doc/Documentation/spi/spidev.
• [2019-10-30][Active] https://github.com/rust-embedded/rust-sysfs-gpio - he sysfs_gpio crate provides access to the Linux sysfs GPIO interface (https://www.kernel.org/doc/Documentation/gpio/sysfs.txt). It seeks to provide an API that is safe, convenient, and efficient and supports exporting, unexporting, reading, writing and waiting for interrupts on pins. Many devices such as the Raspberry Pi or Beaglebone Black provide userspace access to a number of GPIO peripherals. The standard kernel API for providing access to these GPIOs is via sysfs. You might want to also check out the gpio-utils Project for a convenient way to associate names with pins and export them as part of system boot. That project uses this library.
• [2019-10-30][Active] https://github.com/rust-embedded/rust-sysfs-pwm - Linux PWM Access via Sysfs in Rust. A rust library/crate providing access to the Linux sysfs PWM interface (https://www.kernel.org/doc/Documentation/pwm.txt). It seeks to provide an API that is safe, convenient, and efficient.
• [2019-10-30][Active] https://github.com/rust-embedded/rust-raspi3-OS-tutorials - Rust bare-metal and OS tutorials on the Raspberry Pi. This is a work-in-progress rewrite, started on September 2019. You can find the original version of the tutorials here(https://github.com/rust-embedded/rust-raspi3-OS-tutorials/tree/original_version). They are worth checking out for some advanced features that are not yet rewritten, like virtual memory or exception handling. They will be ported over soon, though (if time permits).
• [2019-10-30][Active] https://github.com/rust-embedded/alloc-cortex-m - A heap allocator for Cortex-M processors.
• [2019-10-30][Active] https://github.com/rust-embedded/arm-dcc - Debug Communication Channel (DCC) API(https://developer.arm.com/docs/dui0471/latest/debug-communications-channel)
• [2019-10-30][Active] https://github.com/rust-embedded/showcase - Awesome embedded projects by the Rust community! Preview:
• [2019-10-30][Active] https://github.com/rust-embedded/riscv - Low level access to RISC-V processors.
• [2019-10-30][Active] https://github.com/rust-embedded/riscv-rt - Minimal runtime / startup for RISC-V CPU's.
• [2019-10-30][Active] https://github.com/rust-embedded/cortex-m - Low level access to Cortex-M processors
• [2019-10-30][Active] https://github.com/rust-embedded/cortex-m-rt - Startup code and minimal runtime for Cortex-M microcontrollers.
• [2019-10-30][Active] https://github.com/rtfm-rs/cortex-m-rtfm - Real Time For the Masses (RTFM) framework for ARM Cortex-M microcontrollers https://rtfm.rs
• [2019-10-30][Active] https://github.com/rust-embedded/cortex-m-quickstart - Template to develop bare metal applications for Cortex-M microcontrollers.
• [2019-10-30][Active] https://github.com/rust-embedded/riscv - Low level access to RISC-V processors.
• [2019-10-30][Active] https://github.com/rust-embedded/fixedvec-rs - fixedvec is a Rust library/crate providing a heapless version of the Rust vector type. Although more limited than the libstd version, fixedvec provides a much-needed "managed" array type for embedded systems or other projects that cannot rely on the heap.
• [2019-10-30][Active] https://github.com/rust-embedded/register-rs - Unified interface for type-safe MMIO(Memory mapping I/O) and CPU register access in Rust.
• [2019-10-30][Active] https://github.com/rust-embedded/cargo-binutils - Cargo subcommands to invoke the LLVM tools shipped with the Rust toolchain
• [2019-10-30][Active] https://github.com/rust-embedded/wg#the-tools-team - Embedded devices Working Group
• [2019-10-30][Active] https://github.com/rust-embedded/book - Documentation on how to use the Rust Programming Language to develop firmware for bare metal (microcontroller) devices

Others

• [2019-10-23][Active] https://github.com/kevinmehall/rust-peg - rust-peg is a simple yet flexible parser generator based on the Parsing Expression Grammar formalism. It provides a Rust macro that builds a recursive descent parser from a concise definition of the grammar.
• [2019-10-23][Active] https://github.com/mtojek/ohlavpn - Find working VPN proxy all over the world. Use Hola VPN API to grab a list of fast VPN proxy servers all over the world. Use the IP-API endpoint to check their geolocation and owners (mind the service limits).
• [2019-10-29][Active]https://github.com/dswd/vpncloud - Peer-to-peer VPN. VpnCloud is a simple VPN over UDP. It creates a virtual network interface on the host and forwards all received data via UDP to the destination. VpnCloud establishes a fully-meshed VPN network in a peer-to-peer manner. It can work on TUN devices (IP based) and TAP devices (Ethernet based).

Blockchain

• [2019-10-22][Active] https://github.com/holochain/holochain-rust - The core Holochain framework written in rust, a container API for running it (with rust and node implementations), and hdk-rust library for writing Zomes.
• [2019-10-23][Active] https://github.com/rust-bitcoin/rust-bitcoin - Library with support for de/serialization, parsing and executing on data structures and network messages related to Bitcoin.
• [2019-10-23][Active] https://github.com/libra/libra - too well known. blockchain project.
• [2020-01-15][Active] https://github.com/qtumproject - https://qtum.org/. blockchain project.
• [2019-10-7][Active] https://github.com/paritytech/trie - A generic implementation of the Base-16 Modified Merkle Tree ("Trie") data structure: Trie DB (trie-db crate) and Trie Hash (trie-hash crate). explanation： https://zhuanlan.zhihu.com/p/46702178
• [2019-10-27][Active] https://github.com/tafia/quick-patricia-trie - A toy implementation of a (merkle)patricia tree as used in ethereum. The implementation is strongly inspired by parity patricia-trie. This is a total reimplementation from scratch so there are numerous differences.
• [2019-10-28][Active] https://github.com/exonum/exonum - An extensible open-source framework for creating private/permissioned blockchain applications. xonum can be used to create cryptographically powered distributed ledgers in virtually any problem domain, including FinTech, GovTech, and LegalTech. The Exonum framework is oriented towards creating permissioned blockchains, that is, blockchains with the known set of blockchain infrastructure providers.
• [2019-10-29][Active] https://github.com/cryptape/cita - CITA is a fast and scalable blockchain kernel for enterprises. CITA supports both native contract and EVM contract, by which enterprise users can build their own blockchain applications. CITA has a unique architecture which enables enterprise users to release all their computing resources.
• [2019-10-29][Active] https://github.com/Luminarys/synapse - Synapse is a flexible and fast BitTorrent daemon. It currently supports most systems which implement epoll or kqueue, with a focus on 64-bit linux servers.
• [2019-10-29][Active] https://github.com/paritytech/parity-bitcoin - The Parity Bitcoin client.

Some not relative stuff

• contribuing guide: https://github.com/nix-rust/nix/blob/master/CONTRIBUTING.md; https://github.com/rust-rosetta/rust-rosetta/blob/master/CONTRIBUTING.md
• rfc template: https://github.com/nix-rust/rfcs/blob/master/0000-template.md

License

Licensed under either of

• Apache License, Version 2.0 (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
• MIT license (LICENSE-MIT or http://opensource.org/licenses/MIT)

at your option.

Some Great Contributor

• https://github.com/sfackler
• https://github.com/meh
• https://github.com/mehcode
• https://github.com/seanmonstar
• https://github.com/hyperium
• https://github.com/tokio-rs
• https://github.com/dtolnay
• https://github.com/stepancheg
• https://github.com/cmr
• https://github.com/libp2p
• https://github.com/dgrunwald
• https://github.com/huytd
• https://github.com/BurntSushi
• https://github.com/mre
• https://github.com/bluss - I work on Rust, I teach Rust.
• https://github.com/saschagrunert
• https://github.com/Xudong-Huang - coroutines geek
• https://github.com/huonw
• https://github.com/rajasekarv

Other relative stuff

• https://github.com/crossbario - Seamless connectivity for the IoT and real-time microservices. https://crossbar.io