DOCSEARCHbyAlgolia
Submit Docs

Awesome Rust

repository·main·Indexed 13 days ago

https://github.com/rust-unofficial/awesome-rust

A community-curated directory of high-quality Rust-based applications, libraries, and development resources. It includes categorized lists of software for blockchain, databases, embedded systems, emulators, game development, and graphics, as well as essential development tools and learning materials for the Rust ecosystem.

Tokens
26.8K
Snippets
24
Records
172
Agent score
50%

What's inside Awesome Rust

  1. Overview of Awesome Rust

    main

    Awesome Rust is a curated list of high-quality Rust code, libraries, and resources. It is organized into several major categories to help developers find specific tools and libraries for their needs:

    • Applications: Software built with Rust, categorized by domain (e.g., Blockchain, Databases, Games, Operating Systems, Web Servers).
    • Development tools: Tools for the Rust development lifecycle (e.g., Build systems, Debugging, Formatters, Testing, Static analysis).
    • Libraries: A vast collection of crates and libraries categorized by functionality (e.g., Artificial Intelligence, Asynchronous, Cryptography, Networking, Web programming).
    • Registries: Links to Rust package registries.
    • Resources: Learning materials and general Rust information.

  2. Explore Hardware Abstraction and Peripheral libraries

    main

    For developers working with hardware, embedded systems, or peripherals, the following libraries are available:

    Embedded and Bare-Metal

    • esp-hal: A no_std hardware abstraction layer (HAL) for Espressif ESP32 devices (including ESP32, C2/C3/C5/C6/C61, H2, P4, and S2/S3). It provides safe Rust APIs for GPIO, I2C, SPI, UART, timers, DMA, and more.

    Peripherals and Connectivity

    • serialport: A cross-platform library for accessing serial ports.
    • crabcamera: A Tauri plugin for desktop camera access with hardware controls and quality validation.
    • libfprint-rs: A wrapper around the Linux libfprint library for fingerprint readers.

    Platform-Specific APIs

    • windows-rs: Official Rust support for Windows APIs.
    • winapi-rs: Windows API bindings.
    • nix: Unix-like API bindings.
    • rustix: Safe bindings to POSIX/Unix/Linux/Winsock2 syscalls.
    • inotify-rs: Bindings for inotify (Linux).
    • iptables: Bindings for iptables (Linux).
    • libjail-rs: FreeBSD jail library.
    • fuse-rs: Bindings for FUSE (Filesystem in Userspace).

  3. Explore HTTP Servers

    main

    The following libraries are available for building HTTP servers:

    • branca: Implementation of Branca for Authenticated and Encrypted API tokens.
    • wtx: Low and high-level HTTP/2 server.
    • tower-web: A fast, boilerplate-free web framework.
    • Cot: A web framework designed for ease of use.
    • frank_jwt: JSON Web Token (JWT) implementation.
    • Gotham: A flexible web framework focused on safety, security, and speed.
    • Graphul: An Express-inspired web framework.
    • handlebars-rust: Middleware for the Iron web framework.
    • hyper: A low-level HTTP implementation.
    • Iron: A middleware-based server framework.
    • Juniper: A GraphQL server library.
    • sapper: A lightweight web framework built on async hyper.
    • Nickel: A web framework inspired by Express.
    • rama: A modular service framework for packet transformation and client fingerprinting.
    • poem: A full-featured and easy-to-use web framework.
    • Rustless: A REST-like API micro-framework inspired by Grape and Hyper.
    • Salvo: An easy-to-use web framework based on hyper and tokio.
    • Saphir: A progressive web framework with low-level control.
    • warp: A super-easy, composable web server framework.
    • tiny-http: A low-level HTTP server library.
    • rouille: A web framework.
    • Zino: A next-generation framework for composable applications.

  4. Audio and Music Libraries

    main

    Libraries for handling audio playback, encoding, decoding, and music theory:

    • stream-download: Library for streaming audio, video, and other media content.
    • hound: WAV encoding and decoding library.
    • nodi: Library for playback and abstraction of MIDI files.
    • ears: Simple library to play sounds and music using OpenAL and libsndfile.
    • portmidi-rs: Bindings for PortMidi.
    • rust-music-theory: Library for music theory.
    • Symphonia: Audio decoding and media demuxing supporting AAC, FLAC, MP3, MP4, OGG, Vorbis, and WAV.
    • cpal: Low-level cross-platform audio I/O library.
    • rodio: Audio playback library.
    • rust-portaudio: Bindings for PortAudio.
    • lofty: Library for reading and editing metadata of various audio formats.

  5. Authentication and Security Libraries

    main

    Tools for managing identity, tokens, and authentication flows:

    • totp-rs: 2FA library to generate and verify TOTP-based tokens.
    • gaze: Facial authentication for Linux with on-device recognition and PAM integration.
    • jsonwebtoken: JSON Web Token (JWT) library.
    • oauth2: Extensible, strongly-typed OAuth2 client library.
    • oxide-auth: OAuth2 server library with configurable and pluggable backends (compatible with Actix).
    • jwtvault: Async library for managing and orchestrating JWT workflows.
    • yup-oauth2: OAuth2 client implementation supporting Device, Installed, and Service Account flows.

  6. Transpilation and Translation tools

    main

    Tools for converting code between languages or formats:

    • aleph_ollama: AI-powered source code translation using local Ollama API.
    • m2cgen: CLI tool to transpile trained machine learning models into native Rust code with zero dependencies.
    • c2rust: C to Rust translator and cross checker built on Clang/LLVM.
    • corrode: C to Rust translator written in Haskell.

  7. Explore Rust GUI and UI Frameworks

    main

    The following libraries are available for building graphical user interfaces in Rust, categorized by their underlying technology or paradigm:

    Cross-Platform & General Purpose

    • Dioxus: A portable, performant, and ergonomic framework for building cross-platform UIs.
    • egui: A simple, fast, and highly portable immediate mode GUI library that runs on the web, natively, or in game engines.
    • iced: A cross-platform GUI library focused on simplicity and type-safety, inspired by Elm.
    • Slint: A toolkit for efficiently developing fluid GUIs for embedded devices and desktop applications.
    • Tauri: Build small, fast, and secure desktop applications using a web frontend (powered by wry).
    • Sauron-native: A native and cross-platform GUI library that can run as native GUI, HTML Web, or TUI.
    • Ribir: A framework for building beautiful, native multi-platform applications from a single codebase.
    • Rise-ui: A simple component-based cross-platform GUI toolkit.
    • Blinc: A GPU-accelerated, cross-platform UI framework with a GPUI-inspired builder API and glassmorphism effects.

    Immediate Mode (IMGUI) & Prototyping

    • Azul: A functional, IMGUI-oriented framework supported by Mozilla WebRender.
    • Conrod: An easy-to-use, immediate-mode, 2D GUI library.
    • imgui-rs: Bindings for the ImGui library.
    • Nuklear-rust: Bindings for the Nuklear library.
    • rust_minifb: A cross-platform window setup with optional bitmap rendering, designed primarily for prototyping.

    Bindings to Existing Toolkits

    • GTK+: Use gtk4-rs for GTK4 bindings or relm (an asynchronous, Elm-inspired library).
    • Flutter: Use flutter_rust_bridge for high-level memory-safe bindings, rinf to use Rust as a Flutter backend, or flutter-rs for desktop apps.
    • FLTK: Use fltk-rs for FLTK bindings.
    • Qt: Use qmlrs (QtQuick), rust-qt (Qt), or qmetaobject-rs (integrating QML and Rust via QMetaObject).
    • libui: Use libui-rs for libui bindings.
    • IUP: Use Kiss-ui built on IUP.
    • Sciter: Use rust-sciter for Sciter bindings.

    Specialized & Low-Level

    • autopilot-rs: A simple, cross-platform GUI automation library.
    • core-foundation-rs: Rust bindings to Core Foundation and low-level libraries on macOS and iOS.
    • gpui-component: UI components for building desktop applications using GPUI.
    • makepad: A creative software development platform compiling to WASM/WebGL, macOS/Metal, Windows/DX11, and Linux/OpenGL.
    • OrbTk: A multi-platform (G)UI toolkit using SDL2.
    • xilem: A data-first UI design toolkit (successor to druid).

  8. Find simulation and social network libraries

    main

    The following libraries are categorized for specific domains:

    Simulation

    • nyx-space: High-fidelity astrodynamical toolkit for spacecraft mission design and orbit determination.

    Social networks

    • tdlib-rs: Cross-platform Rust wrapper around the Telegram Database Library (TDLib).

  10. Terminal File Managers

    main

    Various tools for navigating and managing files within a terminal environment:

    • broot: A tool for navigating directory trees, allowing users to get an overview of large directories, search, and cd to found directories.
    • elio: A batteries-included terminal file manager featuring rich previews, bulk actions, and trash support.
    • FileSSH: A TUI for managing files on remote servers via SSH, supporting quick session creation and in-place editing.
    • joshuto: A terminal file manager inspired by ranger.
    • mango-finder: A tool to search files using natural language.
    • pikeru: A Linux file picker with thumbnails and search capabilities.
    • spacedrive: A file manager built on a virtual distributed filesystem.
    • xplr: A minimal, fast, and hackable TUI file explorer.
    • yazi: A high-performance terminal file manager based on async I/O.

  11. Async and Concurrency Libraries

    main

    A collection of libraries for asynchronous programming, task management, and concurrency in Rust:

    • async-std: An asynchronous version of the Rust standard library.
    • dagrs: A high-performance asynchronous task programming framework based on Flow-based Programming.
    • mioco: A scalable, coroutine-based, asynchronous IO handling library.
    • gabriel2: An actor-model library built on top of Tokio.
    • iii-sdk: A distributed runtime for composing services using Worker-Function-Trigger primitives (supports Rust, Node.js, and Python).
    • mio: A lightweight IO library designed to provide minimal overhead over OS abstractions.
    • future-queue: Stream adaptors for running futures concurrently with weighted concurrency limits and optional per-group limits.
    • futures-rs: Zero-cost futures implementation.
    • async-dropper: Implementation of AsyncDrop.
    • fpRust: Functional programming features including Monad/MonadIO, Handler, and Coroutine/doNotation.
    • tokio: A runtime for writing reliable, asynchronous, and slim applications.
    • kameo: Fault-tolerant Async Actors built on Tokio.
    • may: A stackful coroutine library.
    • coio-rs: A coroutine I/O library featuring a work-stealing scheduler.