8000 GitHub - jangtrinh/awesome-rust: Awesome Rust · GitHub
[go: up one dir, main page]
Skip to content

About

Awesome Rust

awesome-rust.com

Resources

Readme

Contributing

Contributing
Activity

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository
BranchesTags
 
 

Repository files navigation

Awesome Rust

lint

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

Projects are selected using our curation criteria. See also related tools, archived projects, and entries awaiting review.

Contributing

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

Table of contents

Applications

See also Friends of Rust (Organizations running Rust in production) and Rust Companies (A curated list of companies using Rust in production).

  • aegis-orchestrator — AEGIS by 100monkeys.ai: a self-hosted orchestrator that runs autonomous agents in isolated, policy-enforced runtimes with durable FSM state. AGPL-3.0, in beta.
  • alacritty — A cross-platform, GPU enhanced terminal emulator
  • AnderEnder/s3find-rs — A command line utility to walk an Amazon S3 hierarchy, an analog of find for Amazon S3
  • asm-cli-rust — interative assembly shell written in rust.
  • cloudflare/boringtun — A Userspace WireGuard VPN Implementation
  • Factotum — A system to programmatically run data pipelines
  • faro — An unofficial Signal client for the terminal, built for tmux and SSH
  • fcsonline/drill — A HTTP load testing application inspired by Ansible syntax
  • ferrum-cli — Rust-native local LLM inference with Metal, CUDA, and OpenAI-compatible serving. Build Status
  • gitside — A VS Code-inspired source-control panel for the terminal.
  • habitat — An tool created by Chef to build, deploy, and manage applications.
  • Herd — an experimental HTTP load testing application
  • Hickory DNS — A DNS client, resolver and server; formerly Trust-DNS.
  • Hyperconsciousness - Developer-alpha Rust CLI and MCP/HTTP server for encrypted, append-only knowledge with scoped, expiring grants.
  • intecture/api — an API-driven server management and configuration tool
  • jedisct1/flowgger — A fast, simple and lightweight data collector
  • limonite — static blog/website generator
  • linkerd/linkerd2-proxy — Ultralight service mesh for Kubernetes.
  • 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
  • nika — Intent-as-code workflow engine for AI: reviewable YAML DAGs statically checked (schema, permits, honest cost floor) before any token is spent. Single binary.
  • 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 10BC8 Status for danielrangel/rsign
  • shaunlee/beanstalkd-rs — A drop-in replacement for beanstalkd: the same work-queue protocol byte for byte, with built-in TLS, Prometheus metrics and optional Raft replication CI
  • Weld — Full fake REST API generator
  • 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.
  • rusty-amp — A complete guitar amp and pedalboard rig with external plugins support that runs right in your terminal.

CI/CD Runners

  • Conveyor — Fast, secure, local-first CI/CD pipelines with a real-time TUI. DAG workflows, cron triggers, and artifact management powered by Rust.

Container Engines

  • Nucleus — A high-performance, minimalistic container engine in Rust

Cryptocurrencies

  • Bitcoin Satoshi's Vision — A Rust library for working with Bitcoin SV .
  • 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
  • infincia/bip39-rs — Rust implementation of BIP39.
  • 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.
  • rbtc — Convert BTC to any currency and vice-versa.
  • wagu — Generate a wallet for any cryptocurrency

Database

  • HelixDB — An open-source graph-vector database written in Rust
  • indradb — Rust based graph database
  • noria — Dynamically changing, partially-stateful data-flow for web application backends
  • ParadeDB - A transactional alternative to Elasticsearch built on Postgres
  • ParityDB — A fast and reliable database optimised for read operations.
  • PumpkinDB — an event sourcing database engine
  • 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.

Media

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
  • NeoPanic/Glim — A macOS file viewer built with Rust and GPUI Kit for Markdown, PDFs, images, JSON, CSV and source code in one workspace
  • koruworks/mono - Koru, a local-first workspace for notes, docs and files with a native Rust UI (not Electron) that stores notes in a local database, for Windows and macOS

Security tools

  • kpcyrd/badtouch — A scriptable network authentication cracker
  • replydev/cotp - Trustworthy, encrypted, command-line TOTP/HOTP authenticator app with import functionality. Actions Status
  • kpcyrd/sniffglue — A secure multithreaded packet sniffer
  • kpcyrd/sn0int — A semi-automatic OSINT framework and package manager
  • elicpeter/nyx — Local-first security scanner with browser UI. Cross-language taint analysis, flow visualiser, and offline triage. No cloud, no account.
  • 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.
  • RustNet - A cross platform real time network monitoring tool. Build Status

System tools

  • brocode/fblog — Small command-line JSON Log viewer
  • buster/rrun — A command launcher for Linux, similar to gmrun
  • Causeway — A standalone Rust MCP server for controlling Chromium through the Chrome DevTools Protocol. [source]
  • chiarorosa/claude-codex-taskbar — Windows 10/11 taskbar widget showing Claude Code and Codex usage limits next to CPU, RAM, GPU and disk activity (raw Win32 + Direct2D, single exe under 1 MB) CI
  • cristianoliveira/funzzy — A configurable filesystem watcher inspired by entr
  • dalance/procs — A modern replacement for 'ps' written by Rust
  • ddh — Fast duplicate file finder
  • dutradotdev/quokka — Terminal-native iPhone inspection and cleanup over USB for macOS. No jailbreak.
  • eza-community/eza — A modern replacement for ls and the maintained successor to exa.
  • fselect — Find files with SQL-like queries
  • gblach/imge — Write disk images to physical drive or vice versa with on-the-fly compression/decompression. Rust check
  • gblach/reflicate — Deduplicate data by creating reflinks between identical files. build
  • Glubiz/zirv - CLI for workflow automation via YAML/JSON/TOML scripts
  • harry0703/MangoDisk — Safety-first disk cleaner and space analyzer for macOS and Windows, with visual storage maps, duplicate detection, app uninstall, and local review before deletion.
  • hex22a/cidit - CIDR Inspection Tool CI
  • j0ru/kickoff — Fast wayland program launcher
  • lotabout/rargs [rargs] — xargs + awk with pattern matching support
  • lotabout/skim — A fuzzy finder in pure rust
  • m4b/bingrep — Greps through binaries from various OSs and architectures, and colors them.
  • mitnk/cicada — A bash-like Unix shell
  • mmstick/fontfinder — GTK3 application for previewing and installing Google's fonts
  • mmstick/tv-renamer — A tv series renaming application with an optional GTK3 frontend.
  • netscanner - TUI Network Scanner
  • nushell/nushell — A multiplatform, data oriented shell and a scripting language
  • Peltoche/lsd — An ls with a lot of pretty colors and awesome icons
  • pop-os/debrep — APT repository tool for building and managing an APT repo
  • pop-os/system76-power — Linux power management daemon (DBus-interface) with CLI tool.
  • Ralvke/logram — Push log files' updates to Telegram
  • redox-os/ion — Next-generation system shell
  • sharkdp/bat — A cat(1) clone with wings.
  • sharkdp/fd — A simple, fast and user-friendly alternative to find. Build Status
  • sitkevij/hex — A colorized hexdump terminal utility.
  • supercilex/fuc - Fast cp and rm commands
  • uutils/coreutils — A cross-platform Rust rewrite of the GNU coreutils
  • watchexec — Executes commands in response to file modifications
  • XAMPPRocky/tokei — counts the lines of code

Text editors

Text processing

  • dathere/qsv — Command-line tools for querying, transforming and validating CSV data.
  • dxpdf – A fast and powerful docx to pdf rendering engine with Skia under the hood.
  • lavifb/todo_r — Find all your TODO notes with one command!
  • ripgrep — combines the usability of The Silver Searcher with the raw speed of grep
  • sd — Intuitive find & replace CLI
  • vishaltelangre/ff — Find files (ff) by name!
  • whitfin/bytelines — Read input lines as byte slices for high efficiency.
  • whitfin/runiq — an efficient way to filter duplicate lines from unsorted input.

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.
  • arthrp/quick-skeleton — Project scaffolding tool, similar to Yeoman and Slush.
  • 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.
  • thanks-stars — CLI that stars the GitHub repositories your project depends on across multiple ecosystems.
  • 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.
  • gitlogue — A TUI screensaver that visualizes Git commit history in your terminal.
  • repoch — Convert epoch to datetime and datetime to epoch
  • arjav0703/cargofetch — A lightweight fetch utility to show metadata about your rust project.

Video

  • salihcantekin/RustFrame — A privacy-focused, cross-platform screen region sharing tool for video calls
  • yuvadm/slingr — A simple CLI for streaming media files over a local network to UPnP media renderers

Virtualization

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
  • 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
  • frolic — An API layer to build customer facing dashboards 10x faster
  • fw — workspace productivity booster
  • git-journal — The Git Commit Message and Changelog Generation Framework
  • just — A handy command runner for project-specific tasks
  • lnds/kimun [kimun] — Code health metrics from the terminal: a project grade from A++ to F--, cyclomatic and cognitive complexity, duplication, Halstead, code smells, and from git history hotspots, ownership, temporal coupling and the blast radius of a change, for 40+ languages CI
  • 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
  • Rust Regex Playground — Web tool to evaluate rust regular expressions
  • rust-lang/rust-analyzer — A language server providing Rust code analysis and editor support.
  • rustfmt — A Rust code formatter
  • Rustup — the Rust toolchain installer
  • Sourcey (crates.io) - Builds self-hosted static Rust API documentation from rustdoc JSON.
  • tinyrick a basic task dependency tool emphasizing Rust functions over raw shell commands.

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-deb — Generates binary Debian packages
    • 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-info — queries crates.io for crates details from command line
    • cargo-lean — A CLI tool for validating and managing lean Cargo package distribution archives by controlling which files are included in published crates.
    • 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-update — cargo subcommand for checking and applying updates to installed executables
    • liuchong/cargo-x — A very simple third-party cargo subcommand to execute a custom command
    • dtolnay/cargo-expand — Expand macros in your source code

Embedded

Rust Embedded

  • Cross compiling
    • 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

Static analysis

[assert, static]

Testing

[testing]

Transpiling

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

Libraries

Artificial Intelligence

Genetic Algorithms

  • NSGA RS - A Rust framework for solving multi-objective optimisation problems using the NSGA family of multi-objective evolutionary algorithms with flexible problem definition, parallel and resumable runs.
  • 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).
  • 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.
  • Cortex Memory - A complete virtual-file-system based solution for agent memory, from extraction and search to automated optimization, and insights dashboard out-of-the-box.

Machine learning

[machine learning]

See also About Rust’s Machine Learning Community.

Astronomy

[astronomy]

  • arthiqlabs/vedaksha — Clean-room astronomical ephemeris and Vedic computation engine with JPL-validated positions, native Jyotish primitives, WebAssembly and Python bindings, and an MCP server.
  • flosse/sun — A Rust port of the JavaScript library suncalc.
  • saurvs/astro-rust — astronomy for Rust

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

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.

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]

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

  • Pebble
    • andars/pebble.rs — A crate that allows Rust to be used to develop Pebble applications.

Network programming

Parsing

Packaging formats

Peripherals

Platform specific

Robotics

  • cerulion-inc/cerulion [cerulion_cli] — Robot runtime with zero-copy shared memory and a graph-aware scheduler. A 1 MiB round trip takes 4.08 µs for native nodes and 11.12 µs for ROS 2 Jazzy over rmw_cerulion, against 10,952 µs for stock ROS 2 Jazzy (medians, one Linux x86-64 desktop, 100 Hz, Sep 2026). Re-executes supported native recordings against new code, with an exit code for CI. CI

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

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.

  • Client-side / WASM
    • cargo-web — A Cargo subcommand for the client-side Web Build Status
    • stdweb — A standard library for the client-side Web Build Status
    • yew — Rust framework for making client web apps
    • tinyweb — A minimal Rust web framework for wasm in 800 lines of code
  • HTTP Client
  • HTTP Server
    • actix/actix-web — A lightweight async web framework for Rust with websocket support
    • branca — A Pure Rust implementation of Branca for Authenticated and Encrypted API tokens.
    • Gotham — A flexible web framework that does not sacrifice safety, security or speed.
  • hyperlane-dev/hyperlane — A lightweight, high-performance, cross-platform Rust HTTP server library built on Tokio with built-in support for middleware, WebSocket, SSE, and raw TCP. CI
    • hyperium/hyper — an HTTP implementation
    • GildedHonour/frank_jwt — JSON Web Token implementation in Rust.
    • Guard-Core/guard-core-rs [guard-core-rs] - Application-layer API security engine with Actix, axum, Rocket and Tower adapters: IP filtering, rate limiting with automatic bans and attack pattern detection.
    • handlebars-rust — an Iron web framework middleware.
    • Iron — A middleware-based server framework
    • Nickel — inspired by Express
    • Rocket — Rocket is web framework for Rust (nightly) with a focus on ease-of-use, expressability, and speed
    • Rustless — A REST-like API micro-framework inspired by Grape and Hyper
    • Saphir — A progressive web framework with low-level control, without the pain.
    • rustforce/sapper — A lightweight web framework built on async hyper, implemented in Rust language.
    • tiny-http — Low level HTTP server library
    • tomaka/rouille — Web framework in Rust
    • carllerche/tower-web [tower-web] — A fast, boilerplate free, web framework for Rust
    • c410-f3r/wtx — A small and fast to compile framework with builtin support for Databases, JSON, middlewares, streaming and many more.
  • WebSocket
  • Miscellaneous
    • cargonauts — A web framework intended for building maintainable, well-factored web apps.
    • pwoolcoc/soup [soup] - A library similar to Pythons BeautifulSoup, designed to enable quick and easy manipulation and querying of HTML documents. Build Status
    • rust-embed — A macro to embed static assets into a Rust binary.
    • utkarshkukreti/select.rs [select] — A library to extract useful data from HTML documents, suitable for web scraping. Build Status
  • Reverse Proxy
  • Static Site Generators

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

Resources

Readme

Contributing

Contributing
Activity

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages
0