Skip to content

awesome-rust-com/awesome-rust

BranchesTags

Repository files navigation

Awesome Rust

lint

A curated list of awesome Rust frameworks, libraries and software. Inspired by awesome-go.

Contributing

Please take a quick gander at the contribution guidelines first. Thanks to all contributors; you rock!

Table of contents

Applications

See also Rust — Production(organizations running Rust in production).

  • alacritty — A cross-platform, GPU enhanced terminal emulator
  • asm-cli-rust — interative assembly shell written in rust.
  • AnderEnder/s3find-rs — A command line utility to walk an Amazon S3 hierarchy, an analog of find for Amazon S3
  • cloudflare/boringtun — A Userspace WireGuard VPN Implementation
  • denoland/deno — A secure JavaScript/TypeScript runtime built with V8, Rust, and Tokio
  • ivanceras/diwata — A database administration tool for postgresql
  • 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.
  • dlecan/generic-dns-update — A tool to update DNS zonefiles with your IP address
  • Factotum — A system to programmatically run data pipelines
  • fcsonline/drill — A HTTP load testing application inspired by Ansible syntax
  • Fractalide — Simple Rust Microservices
  • habitat — An tool created by Chef to build, deploy, and manage applications.
  • Herd — an experimental HTTP load testing application
  • intecture/api — an API-driven server management and configuration tool
  • jedisct1/flowgger — A fast, simple and lightweight data collector
  • kbknapp/docli — A command line utility for managing DigitalOcean infrastructure
  • limonite — static blog/website generator
  • MaidSafe — A decentralized platform.
  • mdBook — A command line utility to create books from markdown files
  • nicohman/eidolon — A steam and drm-free game registry and launcher for linux and macosx
  • 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
  • Sandstorm Collections App
  • Servo — A prototype web browser engine
  • trust-dns — A DNS-server
  • Weld — Full fake REST API generator
  • kytan - High Performance Peer-to-Peer VPN
  • WezTerm — A GPU-accelerated cross-platform terminal emulator and multiplexer written by @wez and implemented in Rust

Audio

  • indiscipline/zrtstr — A command line utility for checking if stereo wav files are faux-stereo (i.e. have identical channels) and converting such files to mono.

Cryptocurrencies

  • 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.
  • coinbase-pro-rs — Coinbase pro client in Rust, supports sync/async/websocket
  • ethaddrgen — Custom Ethereum vanity address generator made in Rust
  • Grin — Evolution of the MimbleWimble protocol
  • hdwallet — BIP-32 HD wallet related key derivation utilities.
  • infincia/bip39-rs — Rust implementation of BIP39.
  • Joystream — A user governed video platform.
  • 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
  • Parity-Bitcoin — The Parity Bitcoin client
  • 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.
  • rust-cardano — Rust implementation of Cardano primitives, helpers, and related applications
  • Substrate — Generic modular blockchain template written in Rust
  • wagu — Generate a wallet for any cryptocurrency
  • zcash — Zcash is an implementation of the "Zerocash" protocol.
  • Holochain — Scalable P2P alternative to blockchain for all those distributed apps you always wanted to build Build Status

Database

  • indradb — Rust based graph database
  • noria — Dynamically changing, partially-stateful data-flow for web application backends
  • PumpkinDB — an event sourcing database engine
  • seppo0010/rsedis — A Redis reimplementation in Rust
  • ParityDB — Fast and reliable database, optimised for read operation
  • SurrealDB — A scalable, distributed, document-graph database in Rust
  • tikv — A distributed KV database in Rust

Emulators

See also crates matching keyword 'emulator'.

Games

See also Games Made With Piston.

Graphics

Industrial automation

Operating systems

See also A comparison of operating systems written in Rust.

Productivity

  • eureka — A CLI tool to input and store your ideas without leaving the terminal
  • BenSchZA/pier — A central repository to manage (add, search metadata, etc.) all your one-liners, scripts, tools, and CLIs

Security tools

  • arvancloud/libinjection-rs — Rust bindings for libinjection
  • kpcyrd/badtouch — A scriptable network authentication cracker
  • replydev/cotp - Trustworthy, encrypted, command-line TOTP/HOTP authenticator app with import functionality. Actions Status
  • kpcyrd/rshijack — A TCP connection hijacker, rust rewrite of shijack
  • kpcyrd/sniffglue — A secure multithreaded packet sniffer
  • kpcyrd/sn0int — A semi-automatic OSINT framework and package manager
  • Gymmasssorla/anevicon — The most powerful UDP-based load generator, written in Rust
  • Gymmasssorla/finshir — A coroutines-driven Low & Slow traffic generator, written in Rust
  • Ockam — A suite of tools, programming libraries and infrastructure that make it easy to build devices that communicate securely, privately and trustfully with cloud services and other devices.

System tools

Text editors

  • gchp/iota — A simple text editor
  • mathall/rim — Vim-like text editor written in Rust
  • Remacs — A community-driven port of Emacs to Rust.
  • xi-editor — A modern editor with a backend written in Rust.
  • xray — An experimental next-generation Electron-based text editor.

Text processing

  • TankerHQ/ruplacer — Find and replace text in source files
  • ripgrep — combines the usability of The Silver Searcher with the raw speed of grep
  • sd — Intuitive find & replace CLI
  • lavifb/todo_r — Find all your TODO notes with one command!
  • whitfin/runiq — an efficient way to filter duplicate lines from unsorted input.
  • whitfin/bytelines — Read input lines as byte slices for high efficiency.
  • vishaltelangre/ff — Find files (ff) by name!
  • xsv — A fast CSV command line tool (slicing, indexing, selecting, searching, sampling, etc.)

Utilities

  • brycx/checkpwn — A Have I Been Pwned (HIBP) command-line utility tool that lets you easily check for compromised accounts and passwords.
  • evansmurithi/cloak — A Command Line OTP (One Time Password) Authenticator application.
  • arthrp/consoletimer - Simple timer for your terminal.
  • myfreeweb/freepass — The free password manager for power users.
  • arthrp/quick-skeleton — Project scaffolding tool, similar to Yeoman and Slush.
  • yaa110/rubigo — Golang dependency tool and package manager, written in Rust
  • 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.
  • Tabiew — A lightweight TUI app to view and query CSV files.
  • Tuckr — A dotfile and symlink manager that requires no configuration, inspired by GNU Stow's approach.
  • 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!
  • aleshaleksey/AZDice — A dice roll success distribution generator for tabletop homebrewers.
  • fcsonline/tmux-thumbs — A lightning fast version of tmux-fingers written in Rust, copy/pasting tmux like vimium/vimperator.
  • repoch — Convert epoch to datetime and datetime to epoch
  • yaa110/cb — Command line interface to manage clipboard Build Status

Video

  • yuvadm/slingr — A simple CLI for streaming media files over a local network to UPnP media renderers

Virtualization

Window managers

Web

Web Servers

  • Man In The Middle Proxy — A MITM Proxy Written in Rust 🦀! Toolkit for HTTP/1, HTTP/2, and WebSockets with SSL/TLS Capabilities.
  • Poem Framework — A full-featured and easy-to-use web framework with the Rust programming language.
  • thecoshman/http — Host These Things Please — A basic http server for hosting a folder fast and simply
  • svenstaro/miniserve — A small, self-contained cross-platform CLI tool that allows you to just grab the binary and serve some file(s) via HTTP
  • TheWaWaR/simple-http-server — simple static http server
  • wyhaya/see — Static file server Build Status
  • Mini RPS - Mini reverse proxy server, HTTPS, CORS, static file hosting and template engine (minijinja)

Development tools

  • ATAC — ATAC is Arguably a Terminal API Client. It is based on well-known clients such as Postman, Insomnia, or even Bruno, but inside your terminal without any specific graphical environment needed.
  • clippy — Rust lints
  • clog-tool/clog-cli — generates a changelog from git metadata (conventional changelog)
  • create-rust-app — Set up a modern rust+react web app by running one command. License: MIT OR Apache-2.0
  • dan-t/rusty-tags — create ctags/etags for a cargo project and all of its dependencies
  • frewsxcv/crate-deps — generates images of dependency graphs for crates hosted on crates.io
  • git-journal — The Git Commit Message and Changelog Generation Framework
  • rust-lang-nursery/rustfix — automatically applies the suggestions made by rustc
  • just — A handy command runner for project-specific tasks
  • Module Linker — Extension that adds <a> links to references in mod, use and extern crate statements at GitHub.
  • Ockam — A suite of tools, programming libraries and infrastructure that make it easy to build devices that communicate securely, privately and trustfully with cloud services and other devices.
  • ptags — A parallel universal-ctags wrapper for git repository Build Status
  • Racer — code completion for Rust
  • rustfmt — A Rust code formatter
  • Rustup — the Rust toolchain installer
  • 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
  • artifact — the design doc tool made for developers Build Status
  • semantic-rs — automatic crate publishing
  • fw — workspace productivity booster
  • tinyrick a basic task dependency tool emphasizing Rust functions over raw shell commands.
  • frolic — An API layer to build customer facing dashboards 10x faster

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
    • 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-graph — updated fork of cargo-dot with additional features. Unmaintained, see cargo-deps
    • cargo-info — queries crates.io for crates details from command line
    • cargo-license — A cargo subcommand to quickly view the licenses of all dependencies.
    • cargo-limit — Cargo with less noise: warnings are skipped until errors are fixed, Neovim integration, etc.
    • 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
  • Github actions
  • Webpack

Debugging

  • GDB
    • rust-gdb
    • gdbgui — Browser based frontend for gdb to debug C, C++, Rust, and go.
  • LLDB
  • rr
    • rr — rr is a lightweight tool for recording and replaying execution of applications

Deployment

Embedded

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
  • Ockam — A suite of tools, programming libraries and infrastructure that make it easy to build devices that communicate securely, privately and trustfully with cloud services and other devices.
  • Arduino

FFI

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.

IDEs

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

Profiling

Services

  • deps.rs — Detect outdated or insecure dependencies
  • docs.rs — Automatic documentation generation of crates

Static analysis

[assert, static]

Testing

[testing]

  • 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
  • httpmock — HTTP mocking build badge
  • 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
  • rust-fuzz/afl.rs — A Rust fuzzer, using AFL
  • 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

Transpiling

  • immunant/c2rust — C to Rust translator and cross checker built atop Clang/LLVM. Build Status
  • jameysharp/corrode — A C to Rust translator written in Haskell.
  • tsync — A utility to generate typescript types from rust code. License: MIT OR Apache-2.0

Libraries

Artificial Intelligence

Genetic Algorithms

  • andschwa/rust-genetic-algorithm — A genetic algorithm for academic benchmark problems
  • thomasbratt/watchmaker — Genetic Algorithm library. Implement a single trait for your problem and call a single method. Supports progress reporting, configurable parameters. CircleCI
  • thomasbratt/watchmaker_vm — A virtual machine for use with genetic algorithms. Any random sequence of bytes is a valid program. Simple orthogonal instruction format. Each instruction is a 64 bit value, including operands. CircleCI
  • 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 — This library allows you to write evolutionary algorithms (EA) using the Rust programming language. Written by Willi Kappler, License: MIT — Version 0.4 (2017.06.26).
  • 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.

Machine learning

[machine learning]

See also About Rust’s Machine Learning Community.

Astronomy

[astronomy]

Asynchronous

  • Async-graphql — Async-graphql is a high-performance server-side library that supports all GraphQL specifications.
  • zonyitoo/coio-rs — A coroutine I/O library with a working-stealing scheduler
  • dpc/mioco — Scalable, coroutine-based, asynchronous IO handling library Travis CI Build Status
  • TeaEntityLab/fpRust — Monad/MonadIO, Handler, Coroutine/doNotation, Functional Programming features for Rust Travis CI Build Status
  • rust-lang-nursery/futures-rs — Zero-cost futures in Rust Travis CI Build Status
  • mio — MIO is a lightweight IO library for Rust with a focus on adding as little overhead as possible over the OS abstractions
  • Xudong-Huang/may — rust stackful coroutine library
  • rustasync/runtime - A runtime agnostic API designed to make async feel like its part of stdlib Crates.io Build status

Audio

[audio]

Authentication

  • Keats/jsonwebtoken — JSON Web Token lib in rust Build Status
  • Ockam — A suite of tools, programming libraries and infrastructure that make it easy to build devices that communicate securely, privately and trustfully with cloud services and other devices.

Automotive

Bioinformatics

  • Rust-Bio — bioinformatics libraries in Rust.

Caching

Concurrency

Cloud

Command-line

Compression

Computation

Configuration

Cryptography

[crypto, cryptography]

)

Database

[database]

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
  • salsa-rs/salsa - A generic framework for on-demand, incrementalized computation.
  • singularity-data/risingwave — RisingWave is a cloud-native streaming database that uses SQL as the interface language.
  • swimos/swim-rust — SwimOS is a framework for building real-time streaming data processing applications build status

Data structures

Data visualization

Date and time

[date, time]

Distributed systems

Email

[email, imap, smtp]

Encoding

[encoding]

Filesystem

[filesystem]

Game development

See also Are we game yet?

Geospatial

[geo, gis]

Graphics

[graphics]

Graph processing

GUI

[gui]

Image processing

Language specification

  • shnewto/bnf — A library for parsing Backus–Naur form context-free grammars.

Logging

[log]

Macro

  • 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

Mobile

Geal/rust_on_mobile

Network programming

Parsing

Packaging formats

Peripherals

Platform specific

Scripting

[scripting]

  • 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
  • Passerine — A small extensible functional scripting language designed for concise expression with little code build
  • jonathandturner/rhai — A tiny and fast embedded scripting language resembling a combination of JS and Rust
  • metacall/core [metacall] — Cross-platform Polyglot Runtime which supports NodeJS, JavaScript, TypeScript, Python, Ruby, C#, Wasm, Java, Cobol and more. build badge

Template engine

Text processing

Text search

Unsafe

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

Virtualization

Web programming

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

Registries

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.

Resources

License

MIT

About

Awesome Rust

awesome-rust.com

Topics

rust awesome awesome-rust

Resources

Readme
Activity
Custom properties

Stars

712 stars

Watchers

25 watching

Forks

66 forks
Report repository

Releases

1 tags

Packages

No packages published

Contributors 41

+ 27 contributors

Languages