Awesome Rust

A curated list of Rust code and resources.

If you want to contribute, please read this.


See also Rust — Production organizations running Rust in production.

  • alacritty — A cross-platform, GPU enhanced terminal emulator
  • asm-cli-rust — An interactive assembly shell written in rust.
  • ballista — PoC of distributed compute platform using Rust, Apache Arrow, and Kubernetes!
  • denoland/deno — A secure JavaScript/TypeScript runtime built with V8, Rust, and Tokio Build Status
  • linkerd/linkerd2-proxy — Ultralight service mesh for Kubernetes.
  • darrint/device-blocker — Limit screen time to children's various mobile devices by blocking internet access on the family Wifi router.
  • Fractalide — Simple Rust Microservices
  • habitat — An tool created by Chef to build, deploy, and manage applications.
  • Herd — an experimental HTTP load testing application
  • jedisct1/flowgger — A fast, simple and lightweight data collector
  • limonite — static blog/website generator
  • MaidSafe — A decentralized platform.
  • mdBook — A command line utility to create books from markdown files Build Status
  • notty — A new kind of terminal
  • Pijul — A patch-based distributed version control system
  • rsign — A simple command-line tool used to generate/sign/verify digital signatures designed to be compatible with Minisign Codeship Status for danielrangel/rsign
  • Rudr — A Kubernetes implementation of the Open Application Model specification
  • Sandstorm Collections App
  • Servo — A prototype web browser engine
  • trust-dns — A DNS-server
  • kytan — High Performance Peer-to-Peer VPN
  • rx — Vi inspired Modern Pixel Art Editor
  • tiny — A terminal IRC client
  • updns — DNS proxy tool

Audio and Music

  • enginesound — A GUI and command line application used to procedurally generate semi-realistic engine sounds. Featuring in-depth configuration, variable sample rate and a frequency analysis window.
  • Spotify TUI — A Spotify client for the terminal written in Rust. Continuous Integration
  • Spotifyd — An open source Spotify client running as a UNIX daemon. Continuous Integration


  • Bitcoin Satoshi's Vision — A Rust library for working with Bitcoin SV .
  • cardano-cli — Cardano Command Line Interface (CLI)
  • ChainX — Fully Decentralized Interchain Crypto Asset Management on Polkadot.
  • CITA — A high performance blockchain kernel for enterprise users.
  • Grin — Evolution of the MimbleWimble protocol
  • hdwallet — BIP-32 HD wallet related key derivation utilities.
  • Holochain — Scalable P2P alternative to blockchain for all those distributed apps you always wanted to build Build Status
  • infincia/bip39-rs — Rust implementation of BIP39.
  • Joystream — A user governed video platform Build Status
  • Libra — Libra’s mission is to enable a simple global currency and financial infrastructure that empowers billions of people.
  • Lighthouse — Rust Ethereum 2.0 Client Build Status
  • nearprotocol/nearcore — decentralized smart-contract platform for low-end mobile devices.
  • Nervos CKB — Nervos CKB is a public permissionless blockchain, the common knowledge layer of Nervos network.
  • Nimiq — Rust implementation of Nimiq node Build Status
  • Parity-Bridge — Bridge between any two ethereum-based networks
  • Parity-Ethereum — Fast, light, and robust Ethereum client
  • Parity-Zcash — Rust implementation of the Zcash protocol
  • Polkadot — Heterogeneous multi‑chain technology with pooled security
  • rbtc — Convert BTC to any currency and vice-versa. Build Status
  • rust-cardano — Rust implementation of Cardano primitives, helpers, and related applications
  • Substrate — Generic modular blockchain template written in Rust
  • zcash — Zcash is an implementation of the "Zerocash" protocol.
  • YeeCo yeeroot — YeeCo yeeroot is a permissionless, secure, high performance and scalable public blockchain platform powered by full sharding technology on PoW consensus written in Rust


  • indradb — Rust based graph database
  • noria — Dynamically changing, partially-stateful data-flow for web application backends
  • Lucid — High performance and distributed KV store accessible through a HTTP API. Build Status
  • ParityDB — Fast and reliable database, optimised for read operation


See also crates matching keyword 'emulator'.


See also Games Made With Piston.


Industrial automation


  • timberio/vector — A High-Performance, Logs, Metrics, & Events Router.
  • Mnwa/gtsa — A simple solution to proxy gelf messages (messages for Graylog) to Sentry
  • OpenTelemetry — OpenTelemetry provides a single set of APIs, libraries, agents, and collector services to capture distributed traces and metrics from your application. You can analyze them using Prometheus, Jaeger, and other observability tools. GitHub Actions CI

Operating systems

See also A comparison of operating systems written in Rust.

  • nebulet/nebulet — A microkernel that implements a WebAssembly "usermode" that runs in Ring 0.
  • redox-os/redox
  • tock/tock — A secure embedded operating system for Cortex-M based microcontrollers


  • espanso — A cross-platform Text Expander written in Rust Build Status
  • eureka — A CLI tool to input and store your ideas without leaving the terminal

Security tools

  • ripasso — A password manager, filesystem compatible with pass

System tools

  • ajeetdsouza/zoxide — A fast alternative to cd that learns your habits release
  • dalance/procs — A modern replacement for 'ps' written by Rust Build Status
  • dust — A more intuitive version of du
  • fselect — Find files with SQL-like queries
  • k0pernicus/zou — A download accelerator
  • Kondo - CLI & GUI tool for deleting software project artifacts and reclaiming disk space
  • mmstick/concurr — Alternative to GNU Parallel w/ a client-server architecture
  • mmstick/fontfinder — GTK3 application for previewing and installing Google's fonts
  • mmstick/parallel — Reimplementation of GNU Parallel
  • organize-rt — Organize files based on regex rules (file extensions by default). pipeline status
  • orhun/kmon — Linux Kernel Manager and Activity Monitor
  • pop-os/debrep — APT repository tool for building and managing an APT repo
  • pop-os/popsicle — GTK3 & CLI utility for flashing multiple USB devices in parallel
  • Luminarys/synapse — Flexible and fast BitTorrent daemon. Build Status
  • pop-os/system76-power — Linux power management daemon (DBus-interface) with CLI tool.
  • Ralvke/logram — Push log files' updates to Telegram
  • unwrittenfun/hotkey-rs — A library to listen to global hotkeys in Rust
  • sharkdp/fd — A simple, fast and user-friendly alternative to find. Build Status
  • slai11/goto — A simple and user-friendly way to jump to your indexed directories. GitHub Workflow Status
  • ytop - A TUI system monitor written in Rust Build status

Text editors

  • amp — Inspired by Vi/Vim.
  • mathall/rim — Vim-like text editor written in Rust
  • xi-editor — A modern editor with a backend written in Rust.

Text processing

  • ripgrep — combines the usability of The Silver Searcher with the raw speed of grep
  • phiresky/ripgrep-all — ripgrep, but also search in PDFs, E-Books, Office documents, zip, tar.gz, etc. Build Status
  • sd — Intuitive find & replace CLI
  • whitfin/runiq — an efficient way to filter duplicate lines from unsorted input.
  • whitfin/bytelines — Read input lines as byte slices for high efficiency.
  • xsv — A fast CSV command line tool (slicing, indexing, selecting, searching, sampling, etc.)
  • Lisprez/so_stupid_search — A simple and fast string search tool for human beings

Image processing

  • Imager — Automated image optimization.


  • yaa110/cb — Command line interface to manage clipboard Build Status
  • brycx/checkpwn — A Have I Been Pwned (HIBP) command-line utility tool that lets you easily check for compromised accounts and passwords.
  • tversteeg/emplace — Synchronize installed packages on multiple machines
  • myfreeweb/freepass — The free password manager for power users.
  • raftario/licensor — write licenses to stdout GitHub Actions
  • whitfin/s3-concat — A command line tool to concatenate Amazon S3 files remotely using flexible patterns.
  • whitfin/s3-meta — A command line tool to gather metadata about your Amazon S3 buckets.
  • whitfin/s3-utils — A small tool containing utilities based around Amazon S3 to provide additional convenience APIs.
  • gorros/s3-edit-rs — A command line tool to edit a file directly on Amazon S3.
  • fcsonline/tmux-thumbs — A lightning fast version of tmux-fingers written in Rust, copy/pasting tmux like vimium/vimperator.
  • amar-laksh/workstation — A commandline tool to help you manage your workstation by distancing you from your screen, locking your screen when you aren't there among other things with OPENCV!
  • guoxbin/dtool — A useful command-line tool collection to assist development including conversion, codec, hashing, encryption, etc. Build Status
  • nomino — Batch rename utility for developers Build Status


  • yuvadm/streamlib — Play your favorite live video and audio streams from command line



  • LemmyNet/lemmy — A link aggregator / reddit clone for the fediverse Build Status

Web Servers

Development tools

  • clippy — Rust lints
  • frewsxcv/crate-deps — generates images of dependency graphs for crates hosted on
  • gstats — command line tool to print a developer handy summary of all git repositories below current directory
  • rust-lang/rustfix — automatically applies the suggestions made by rustc
  • Module Linker — Extension that adds <a> links to references in mod, use and extern crate statements at GitHub.
  • ptags — A parallel universal-ctags wrapper for git repository Build Status
  • Rust Language Server — A server that runs in the background, providing IDEs, editors, and other tools with information about Rust programs
  • Rust Regex Playground — Web tool to evaluate rust regular expressions
  • Rust Search Extension — A handy browser extension to search crates and docs in address bar (omnibox). Build Status
  • artifact — the design doc tool made for developers Build Status
  • tinyrick a basic task dependency tool emphasizing Rust functions over raw shell commands.
  • scriptisto A language-agnostic "shebang interpreter" that enables you to write one file scripts in compiled languages. Build Status

Build system

  • Cargo — the Rust package manager
  • cargo-benchcmp — A utility to compare Rust micro-benchmarks
  • cargo-bitbake — A cargo extension that can generate BitBake recipes utilizing the classes from meta-rust
  • cargo-cache — inspect/manage/clean your cargo cache (~/.cargo//${CARGO_HOME}), print sizes etc Build Status
  • cargo-check — A wrapper around cargo rustc -- -Zno-trans which can be helpful for running a faster compile if you only need correctness checks
  • cargo-count — lists source code counts and details about cargo projects, including unsafe statistics
  • cargo-deb — Generates binary Debian packages
  • cargo-deps — build dependency graphs of Rust projects
  • cargo-do — run multiple cargo commands in a row
  • cargo-ebuild — cargo extension that can generate ebuilds using the in-tree eclasses
  • cargo-edit — allows you to add and list dependencies by reading/writing to your Cargo.toml file from the command line
  • cargo-find deprecated — Find crates from command line
  • cargo-generate A generator of a rust project by leveraging a pre-existing git repository as a template
  • cargo-graph — updated fork of cargo-dot with additional features. Unmaintained, see cargo-deps
  • cargo-info — queries for crates details from command line
  • cargo-license — A cargo subcommand to quickly view the licenses of all dependencies.
  • cargo-make — Rust task runner and build tool.
  • cargo-modules — A cargo plugin for showing a tree-like overview of a crate's modules.
  • cargo-multi — runs specified cargo command on multiple crates
  • cargo-outdated — displays when newer versions of Rust dependencies are available, or out of date
  • cargo-release — tool for releasing git-managed cargo project, build, tag, publish, doc and push
  • cargo-script — lets people quickly and easily run Rust "scripts" which can make use of Cargo's package ecosystem
  • cargo-testify — watches files changes, runs tests and notifies about the result with friendly OS notification
  • cargo-tree – Cargo subcommand that visualizes a crate's dependency graph in a tree-like format CircleCI
  • cargo-update — cargo subcommand for checking and applying updates to installed executables
  • cargo-watch — utility for cargo to compile projects when sources change
  • liuchong/cargo-x — A very simple third-party cargo subcommand to execute a custom command
  • dtolnay/cargo-expand — Expand macros in your source code
  • CMake
  • Devolutions/CMakeRust — useful for integrating a Rust library into a CMake project
  • SiegeLord/RustCMake — an example project showing usage of CMake with Rust
  • Github actions
  • icepuma/rust-action — rust github action
  • peaceiris/actions-mdbook — GitHub Actions for mdBook
  • GitHub webhooks
  • snare — GitHub webhooks runner daemon
  • Webpack
  • Ralvke/rust-loader — Webpack Rust loader (wasm)


  • GDB
  • rust-gdb
  • gdbgui — Browser based frontend for gdb to debug C, C++, Rust, and go.
  • LLDB
  • — allows to use LLDB in a way similar to GDB's batch mode.
  • CodeLLDB — A LLDB extension for Visual Studio Code.
  • rr
  • rr — rr is a lightweight tool for recording and replaying execution of applications



Rust Embedded

  • Cross compiling
  • japaric/rust-cross — everything you need to know about cross compiling Rust programs
  • japaric/xargo — effortless cross compilation of Rust programs to custom bare-metal targets like ARM Cortex-M
  • Raspberry Pi
  • Ogeon/rust-on-raspberry-pi — instructions for how to cross compile Rust projects for the Raspberry Pi .
  • Arduino
  • avr-rust/ruduino `t Reusable components for the Arduino Uno.


See also Foreign Function Interface, The Rust FFI Omnibus (a collection of examples of using code written in Rust from other languages) and FFI examples written in Rust.


See also Are we (I)DE yet? and Rust Tools.

Pattern recognition

  • sfikas/rusteval — A tool used to evaluate the output of retrieval algorithms Build Status



  • — Detect outdated or insecure dependencies
  • — Automatic documentation generation of crates

Static analysis

[assert, static]



  • mockiato — A strict, yet friendly mocking library for Rust 2018
  • mutagen — A source-level mutation testing framework (nightly only)
  • AlKass/polish — Mini Testing/Test-Driven Framework Build Status Crates Package Status
  • proptest — property testing framework inspired by the Hypothesis framework for Python
  • quickcheck — A Rust implementation of QuickCheck
  • mockito — HTTP mocking
  • speculate — An RSpec inspired minimal testing framework for Rust
  • tarpaulin — A code coverage tool designed for Rust
  • trust — A Travis CI and AppVeyor template to test your Rust crate on 5 architectures and publish binary releases of it for Linux, macOS and Windows



Artificial Intelligence

Genetic algorithms

  • Martin1887/oxigen — Fast, parallel, extensible and adaptable genetic algorithm library. A example using this library solves the N Queens problem for N = 255 in only few seconds and using less than 1 MB of RAM.
  • innoave/genevo — Execute genetic algorithm (GA) simulations in a customizable and extensible way.
  • willi-kappler/darwin-rs — Evolutionary algorithms with Rust Build Status
  • m-decoster/RsGenetic — Genetic Algorithm library in Rust. In maintenance mode.
  • mneumann/evo-rs — Evolutionary Algorithm Library for Rust. Without changes for 3 years.
  • yurytsoy/revonet — Rust implementation of real-coded GA for solving optimization problems and training of neural networks.
  • pkalivas/radiate — A customizable parallel genetic programming engine capable of evolving solutions for supervised, unsupervised, and reinforcement learning problems. Comes with complete and customizable implementation of NEAT and Evtree. Build Status

Machine learning

[machine learning]

See also About Rust’s Machine Learning Community.



  • fitsio — fits interface library wrapping cfitsio


  • rustasync/runtime — A runtime agnostic API designed to make async feel like its part of stdlib Build status

Audio and Music





  • Rust-Bio — bioinformatics libraries in Rust.









[crypto, cryptography]



Data processing

  • bluss/ndarray — N-dimensional array with array views, multidimensional slicing, and efficient operations
  • kernelmachine/utah — Dataframe structure and operations in Rust
  • weld-project/weld — High-performance runtime for data analytics applications

Data structures

Data visualization

Date and time

[date, time]

Distributed systems


[email, imap, smtp]




[filesystem] * Operations * pop-os/dbus-udisks2 -> UDisks2 DBus API * pop-os/sys-mount — High level abstraction for the mount / umount2 system calls. * vitiral/path_abs — Absolute serializable path types and associated methods. * webdesus/fs_extra — expanding opportunities standard library std::fs and std::io * Temporary Files * rust-lang-deprecated/tempdir — temporary directory library * Stebalien/tempfile — temporary file library * Stebalien/xattr [xattr] — list and manipulate unix extended file attributes * zboxfs/zbox [zbox] — Zero-details, privacy-focused embeddable file system.

Functional Programming

[functional programming] * Prelude * JasonShin/ — A library for functional programming in Rust Build Status

Game development

See also Are we game yet? * Allegro * SiegeLord/RustAllegroAllegro 5 bindings * Challonge * vityafx/challonge-rs [challonge] — Client library for the Challonge REST API. Helps to organize tournaments. * Corange * lucidscape/corange-rsCorange bindings * Entity-Component Systems (ECS) * amethyst/specs — Specs Parallel ECS * Game Engines * Amethyst — Data-oriented game engine * Piston * ggez — A lightweight game framework for making 2D games with minimum friction * Kiss3d — A Keep It Simple, Stupid 3d graphics engine written with Rust * Unrust — unrust — A pure rust based (webgl 2.0 / native) game engine * Vulkust — Vulkust — A safe, highly multithreaded, Vulkan based game engine written with Rust. * SDL [sdl] * brson/rust-sdl — SDL1 bindings * Rust-SDL2/rust-sdl2 — SDL2 bindings * SFML * jeremyletang/rust-sfmlSFML bindings * Tcod-rs * tomassedovic/tcod-rs — Libtcod bindings for Rust. * Victorem * VictoremWinbringer/Victorem [Victorem] — Easy UDP Game Server and UDP Client framework for creating simple 2D and 3D online game prototype * Voxlap * bbodi/rust-voxlapVoxlap bindings * Awesome wgpu — A curated list of wgpu code and resources


[geo, gis]



Graph processing



Image processing

Language specification



  • seanmonstar/pretty-env-logger — A pretty, easy-to-use logger for Rust. Build Status
  • rust-lang/log — Logging implementation for Rust Build Status
  • slog-rs/slog — Structured, composable logging for Rust Build Status
  • estk/log4rs — highly configurable logging framework modeled after Java's Logback and log4j libraries CircleCI
  • tokio-rs/tracing — An application level tracing framework for async-aware structured logging, error handling, metrics, and more Build Status


  • cute
  • mattgathu/cute — Macro for Python-esque list comprehensions in Rust. Build Status
  • hado
  • ludat/hado-rs — A little macro for writing haskell-like do expressions without too much ceremony

Markup language



  • Android
  • rust-windowing/android-rs-glue — glue between Rust and Android
  • iOS
  • TimNN/cargo-lipo — A cargo lipo subcommand which automatically creates a universal library for use with your iOS application.
  • vhbit/ObjCrust — using Rust to create an iOS static library
  • Pebble
  • andars/ — A crate that allows Rust to be used to develop Pebble applications.
  • Android / iOS
  • i-schuetz/rust_android_ios — An example of using a shared Rust lib for Android and iOS using rust-swig and cbindgen respectively.

Network programming


Packaging formats


Platform specific



  • PistonDevelopers/dyon — A rusty dynamically typed scripting language
  • gluon-lang/gluon — A small, statically-typed, functional programming language
  • murarth/ketos — A Lisp dialect functional programming language serving as a scripting and extension language for rust
  • moss — A dynamically typed scripting language
  • jonathandturner/rhai — A tiny and fast embedded scripting language resembling a combination of JS and Rust



  • bigbang - Gravitational and collisional n-body simulation with optional GPU acceleration
  • nyx-space - High fidelity, fast, reliable and validated astrodynamical toolkit library, used for spacecraft mission design and orbit determination Build Status

Template engine

Text processing


  • zerocopy — Utilities for safely reinterpreting arbitrary byte sequences as native Rust types


Web programming

See also Are we web yet? and Rust web framework comparison.


A registry allows you to publish your Rust libraries as crate packages, to share them with others publicly and privately.

  • Crates — The official public registry for Rust/Cargo.
  • Cloudsmith 💲 — A fully managed package management SaaS, with first-class support for public and private Cargo/Rust registries (plus many others). Has a generous free-tier and is also completely free for open-source.