Awesome Rust

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 Friends of Rust (Organizations running Rust in production) and Rust Companies (A curated list of companies using 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
- 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
- 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

- Moresyl/dsh-studio — Cross-platform desktop studio for installing, supervising, and managing DeepSeek Harness.

- 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

- Sandstorm Collections App
- Servo — A prototype web browser engine
- trust-dns — A DNS-server

- Tura — A local, open-source coding agent with terminal, TUI, and desktop interfaces.
- 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.

- 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 .
- 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

Database
- indradb — Rust based graph database

- HelixDB — An open-source graph-vector database written in Rust

- noria — Dynamically changing, partially-stateful data-flow for web application backends

- PumpkinDB — an event sourcing database engine

- seppo0010/rsedis — A Redis reimplementation in Rust

- ParadeDB - A transactional alternative to Elasticsearch built on Postgres
- 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

Emails
- Bichon — A lightweight, high-performance Rust email archiver with WebUI
Emulators
See also crates matching keyword 'emulator'.
- Commodore 64
- Gameboy
- NES
- Playstation
- ZX Spectrum
- Virtual Boy
- Intel 8080 CPU
- Emulator Development tools
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

- chrispaig3/expo - A Rusty CLI tool for managing the accessibility of GitHub repositories at scale.
- 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.

- 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

- elicpeter/nyx — Local-first security scanner with browser UI. Cross-language taint analysis, flow visualiser, and offline triage. No cloud, no account.

- 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.

- RustNet - A cross platform real time network monitoring tool.

- SystemVll/TAuth - An easy, memory safe and user friendly 2FA & Credentials manager, for your PC.
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.)

- dxpdf – A fast and powerful docx to pdf rendering engine with Skia under the hood.
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.
- 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

- yaa110/cb — Command line interface to manage clipboard

- arjav0703/cargofetch — A lightweight fetch utility to show metadata about your rust project.
- Saga Reader - A Blazing-Fast and Extremely-Lightweight Internet Reader driven by AI.Supports fetching of search engine information and RSS.
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
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

- Mini RPS - Mini reverse proxy server, HTTPS, CORS, static file hosting and template engine (minijinja)
- 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.

- 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

- 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

- 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

- 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
- Docker
- Google App Engine
- Heroku
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.
- C
- C++
- Erlang
- Haskell
- Java
- Lua
- mruby
- Node.js
- Objective-C
- Perl
- Python
- getsentry/milksnake — extension for python setuptools that allows you to distribute dynamic linked libraries in Python wheels in the most portable way imaginable.
- dgrunwald/rust-cpython — Python bindings

- PyO3/PyO3 — Rust bindings for the Python interpreter

- R
- Ruby
- Web Assembly
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

Profiling
Services
- deps.rs — Detect outdated or insecure dependencies
- docs.rs — Automatic documentation generation of crates
Static analysis
[assert, static]
Testing
[testing]
- googletest-json-serde — A collection of JSON matchers for googletest-rust, supporting paths, arrays, and objects.

- 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

- httpmock — HTTP mocking

- 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
- xezim — An Extensible SystemVerilog simulator and verification engine.
Transpiling
- immunant/c2rust — C to Rust translator and cross checker built atop Clang/LLVM.

- jameysharp/corrode — A C to Rust translator written in Haskell.
- tsync — A utility to generate typescript types from rust code.

Libraries
Artificial Intelligence
Genetic Algorithms
- andschwa/rust-genetic-algorithm — A genetic algorithm for academic benchmark problems

- 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.

- 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.

- 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.
- 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]
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

- TeaEntityLab/fpRust — Monad/MonadIO, Handler, Coroutine/doNotation, Functional Programming features for Rust

- rust-lang-nursery/futures-rs — Zero-cost futures in Rust

- 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

Audio
[audio]
Authentication
- Keats/jsonwebtoken — JSON Web Token lib 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.

Automotive
- Rust-Bio — bioinformatics libraries in Rust.
Caching
Concurrency
Cloud
Command-line
- Argument parsing
- Human-centered design
- Line editor
- Pipeline
- Progress
- Prompt
- Style
- TUI
Compression
- Brotli
- bzip2
- gzip
- miniz
- snappy
- tar
- zip
Computation
Configuration
Cryptography
[crypto, cryptography]
- briansmith/ring — Safe, fast, small crypto using Rust and BoringSSL's cryptography primitives.

- briansmith/webpki — Web PKI TLS X.509 certificate validation in Rust.

- brycx/orion — This library aims to provide easy and usable crypto. 'Usable' meaning exposing high-level API's that are easy to use and hard to misuse.

- ctz/rustls — A Rust implementation of TLS
- DaGenix/rust-crypto — cryptographic algorithms in Rust

- dnaq/sodiumoxide — libsodium bindings

- doublify/libblockchain — A Blockchain implementation

- exonum/exonum [exonum] — extensible framework for blockchain projects

- klutzy/suruga — A Rust implementation of TLS 1.2
- libOctavo/octavo — Modular hash and crypto library 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.

- RustCrypto/hashes — Collection of cryptographic hash functions written in pure Rust

- rustindia/mpw-rs — Pure Rust implementation of the Master Password password manager

- Fraunhofer-AISEC/rabe — Library providing several Attribute-Based Encryption (ABE) schemes
- racum/rust-djangohashers — A Rust port of the password primitives used in the Django Project. It doesn't require Django, only hashes and validates passwords according to its style.

- RNCryptor/rncryptor-rs — Pure Rust implementation of the RNCryptor AES file format
- conradkdotcom/rooster [rooster] — Simple password manager to use in your terminal
- michoo/spasm — SPASM Smol PASsword Manager to use in your terminal, very simple to modify. With argon2, password generators(random, Dice,..), Check password complexity (Shannon), Check password on HIBP (Have I Been Pwnd),...
- sfackler/rust-native-tls — Bindings for native TLS libraries
- sfackler/rust-openssl — OpenSSL bindings

- kornelski/rust-security-framework — Bindings for Security Framework (OSX native
)
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

Data structures
Data visualization
Date and time
[date, time]
Distributed systems
- Antimony
- Apache Hadoop
- whitfin/efflux — Easy Hadoop Streaming and MapReduce interfaces in Rust.
- Apache Kafka
- Beanstalkd
- HDFS
- Zenoh
- eclipse-zenoh/zenoh - A distributed programming framework that unifies data in motion, data at rest and computations. It elegantly blends traditional pub/sub with geo distributed storages, queries and computations, while retaining a level of time and space efficiency that is well beyond any of the mainstream stacks.

Email
[email, imap, smtp]
Encoding
[encoding]
- ASN.1
- Bencode
- Binary
- BSON
- Byte swapping
- Cap'n Proto
- CBOR
- Character Encoding
- CRC
- CSV
- FlatBuffers
- frol/flatc-rust — FlatBuffers compiler (flatc) integration for Cargo build scripts

- HAR
- mandrean/har-rs — A HTTP Archive Format (HAR) serialization & deserialization library

- HTML
- Ion
- JSON
- Jsonnet
- MsgPack
- PEM
- Postman Collection
- ProtocolBuffers
- RON (Rusty Object Notation)
- Tnetstring
- TOML
- XML
- YAML
Filesystem
[filesystem]
- Operations
- Temporary Files
Game development
See also Are we game yet?
- Allegro
- Challonge
- Corange
- Entity-Component Systems (ECS)
- Game Engines
- Amethyst — Data-oriented game engine

- Bevy — A data-driven game engine built in Rust
- 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]
- SFML
- Tcod-rs
- Victorem
- Voxlap
Geospatial
[geo, gis]
Graphics
[graphics]
Graph processing
GUI
[gui]
-
autopilot-rs/autopilot-rs — A simple, cross-platform GUI automation library for Rust.
-
euv-dev/euv — A declarative, cross-platform UI framework for Rust with virtual DOM, reactive signals, and HTML macros for WebAssembly. 
-
maps4print/azul — A free, functional, IMGUI-oriented GUI framework for rapid development of desktop applications written in Rust, supported by the Mozilla WebRender rendering engine. 
-
PistonDevelopers/conrod — An easy-to-use, immediate-mode, 2D GUI library written entirely in Rust 
-
rise-ui — Simple component-based cross-Platform GUI Toolkit for developing beautiful and user-friendly interfaces.
-
Cocoa
-
Flutter
- flutter-rs — Build flutter desktop app in dart & rust.
-
GTK+ [gtk]
- gtk-rs/gtk — GTK+ bindings

- relm — Asynchronous, GTK+-based, GUI library, inspired by Elm

-
ImGui
-
IUP
-
libui
-
Nuklear
-
Qt
-
saurvs/nfd-rs — nativefiledialog bindings
-
Sciter
-
tauri Rust GUI using OS WebView and HTML & CSS
Image processing
Language specification
- shnewto/bnf — A library for parsing Backus–Naur form context-free grammars.

Logging
[log]
Macro
- cute
- hado
- ludat/hado-rs — A little macro for writing haskell-like do expressions without too much ceremony
Markup language
Mobile
Geal/rust_on_mobile
- 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/pebble.rs — A crate that allows Rust to be used to develop Pebble applications.
Network programming
- HTTP
- FTP
- IPNetwork
- JSON-RPC
- Low level
- libpnet/libpnet — A cross-platform, low level networking

- m-labs/smoltcp — A standalone, event-driven TCP/IP stack that is designed for bare-metal, real-time systems

- tokio-rs/tokio — A network application framework for rapid development and highly scalable production deployments of clients and servers.
- dylanmckay/protocol — Custom TCP/UDP protocol definitions
- slawlor/ractor - Actor library for Rust
- NanoMsg
- Nng
- NNTP
- mattnenterprise/rust-nntp — an NNTP client for 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.

- POP3
- SSH
- Stomp
- uTP
- ZeroMQ
- CoAP
- Zenoh
- eclipse-zenoh/zenoh - A protocol that unifies data in motion, data at rest and computations. It elegantly blends traditional pub/sub with geo distributed storages, queries and computations, while retaining a level of time and space efficiency that is well beyond any of the mainstream stacks.

Parsing
Peripherals
-
Cross-platform
- svartalf/rust-battery — Cross-platform information about the notebook batteries

- Open-Vanguard/zinc - Gives processes in any language direct access to the same physical memory. No serialization. No copies. No kernel round-trips.
-
Linux
-
Unix-like
-
Windows
-
FreeBSD
Robotics
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

- 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.

Template engine
- Handlebars
- HTML
- Mustache
- tailhook/marafet — Compiler for Jade-like template language to cito.js-based virtual dom
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

- seed - A Rust framework for creating web apps

- stdweb — A standard library for the client-side Web

- 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.
- WebSocket
- Miscellaneous
- cargonauts — A web framework intended for building maintainable, well-factored web apps.
- pyros2097/rust-embed — A macro to embed static assets into the rust binary
- utkarshkukreti/select.rs [select] — A library to extract useful data from HTML documents, suitable for web scraping.

- pwoolcoc/soup [soup] - A library similar to Pythons BeautifulSoup, designed to enable quick and easy manipulation and querying of HTML documents.

- 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 :heavy_dollar_sign: - 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