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.
Awesome Rust
This page lists names, links and short descriptions. The original list on GitHub is the source and belongs to its authors.
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.
A command line utility to walk an Amazon S3 hierarchy, an analog of find for Amazon S3
interative assembly shell written in rust.
A Userspace WireGuard VPN Implementation
A system to programmatically run data pipelines
An unofficial Signal client for the terminal, built for tmux and SSH
A HTTP load testing application inspired by Ansible syntax
Rust-native local LLM inference with Metal, CUDA, and OpenAI-compatible serving.
A VS Code-inspired source-control panel for the terminal.
An tool created by Chef to build, deploy, and manage applications.
an experimental HTTP load testing application
A DNS client, resolver and server; formerly Trust-DNS.
Developer-alpha Rust CLI and MCP/HTTP server for encrypted, append-only knowledge with scoped, expiring grants.
an API-driven server management and configuration tool
A fast, simple and lightweight data collector
static blog/website generator
Ultralight service mesh for Kubernetes.
A decentralized platform.
A command line utility to create books from markdown files
A steam and drm-free game registry and launcher for linux and macosx
Intent-as-code workflow engine for AI: reviewable YAML DAGs statically checked (schema, permits, honest cost floor) before any token is spent. Single binary.
A new kind of terminal
A patch-based distributed version control system
A simple command-line tool used to generate/sign/verify digital signatures designed to be compatible with Minisign
A drop-in replacement for beanstalkd: the same work-queue protocol byte for byte, with built-in TLS, Prometheus metrics and optional Raft replication
Full fake REST API generator
A GPU-accelerated cross-platform terminal emulator and multiplexer written by @wez and implemented in Rust
A command line utility for checking if stereo wav files are faux-stereo (i.e. have identical channels) and converting such files to mono.
A complete guitar amp and pedalboard rig with external plugins support that runs right in your terminal.
Fast, secure, local-first CI/CD pipelines with a real-time TUI. DAG workflows, cron triggers, and artifact management powered by Rust.
A high-performance, minimalistic container engine in Rust
A Rust library for working with Bitcoin SV .
Fully Decentralized Interchain Crypto Asset Management on Polkadot.
Coinbase pro client in Rust, supports sync/async/websocket
Custom Ethereum vanity address generator made in Rust
Evolution of the MimbleWimble protocol
Rust implementation of BIP39.
decentralized smart-contract platform for low-end mobile devices.
Nervos CKB is a public permissionless blockchain, the common knowledge layer of Nervos network.
Convert BTC to any currency and vice-versa.
Generate a wallet for any cryptocurrency
Rust based graph database
[kividb] — A Redis-compatible in-memory database and cache, with persistence, replication, clustering, search, vector search and JSON
Dynamically changing, partially-stateful data-flow for web application backends
A transactional alternative to Elasticsearch built on Postgres
A fast and reliable database optimised for read operations.
an event sourcing database engine
A scalable, distributed, document-graph database in Rust
A distributed KV database in Rust
Commodore 64 emulator
A Game Boy research project and emulator
A Gameboy Emulator
Full featured Cross-platform GameBoy emulator. Forever boys!.
A NES emulator
A PlayStation emulator and the successor to Rustation.
For WebAssembly, live version here
ROM analyser/extractor
A minimalistic music video game which supports the BMS format
A Sokoban implementation
A turn-based hexagonal strategy game . Discontinued. There are no forks.
hexagonal ascii roguelike
The city sim you deserve
A CLI code-typing game that turns your source code into typing challenges
A small 2D turn-based hexagonal strategy game
A roguelike game in Rust
Snake written in Rust.
A simple connect four implementation.
A renderer for Doom, may progress to being a playable game
Quake map renderer in Rust
An RPG with turned-based mechanics (work in progress)
Extensible open world rogue like game with pixel art
An open-world, open-source multiplayer voxel RPG.
A TUI app for MyAnimelist.
Vector-based graphics editor
A real-time 4D CPU ray tracer
[lini] — A small language for every kind of figure: diagrams, charts, sequences, schematics, technical drawings, compiled from plain text to themeable SVG
converts ASCII diagrams into SVG graphics
Free desktop interface design app that opens and saves .fig files, with a built-in MCP server for AI coding agents
A ray tracer
CLI for processing images, generating histograms.
A tokio-based modbus library.
A pure rust OPC UA library.
A pure rust modbus library with no or less dependencies.
An OS kernel written in rust. Non POSIX
A CLI tool to input and store your ideas without leaving the terminal
A central repository to manage (add, search metadata, etc.) all your one-liners, scripts, tools, and CLIs
A macOS file viewer built with Rust and GPUI Kit for Markdown, PDFs, images, JSON, CSV and source code in one workspace
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
A scriptable network authentication cracker
Trustworthy, encrypted, command-line TOTP/HOTP authenticator app with import functionality.
A secure multithreaded packet sniffer
A semi-automatic OSINT framework and package manager
Local-first security scanner with browser UI. Cross-language taint analysis, flow visualiser, and offline triage. No cloud, no account.
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.
Small command-line JSON Log viewer
A command launcher for Linux, similar to gmrun
A standalone Rust MCP server for controlling Chromium through the Chrome DevTools Protocol. [source]
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)
A configurable filesystem watcher inspired by entr
A modern replacement for 'ps' written by Rust
Fast duplicate file finder
Terminal-native iPhone inspection and cleanup over USB for macOS. No jailbreak.
A modern replacement for ls and the maintained successor to exa.
Find files with SQL-like queries
Write disk images to physical drive or vice versa with on-the-fly compression/decompression.
Deduplicate data by creating reflinks between identical files.
CLI for workflow automation via YAML/JSON/TOML scripts
Safety-first disk cleaner and space analyzer for macOS and Windows, with visual storage maps, duplicate detection, app uninstall, and local review before deletion.
CIDR Inspection Tool
Fast wayland program launcher
[rargs] — xargs + awk with pattern matching support
A fuzzy finder in pure rust
Greps through binaries from various OSs and architectures, and colors them.
A bash-like Unix shell
GTK3 application for previewing and installing Google's fonts
A tv series renaming application with an optional GTK3 frontend.
TUI Network Scanner
A multiplatform, data oriented shell and a scripting language
An ls with a lot of pretty colors and awesome icons
APT repository tool for building and managing an APT repo
Linux power management daemon (DBus-interface) with CLI tool.
Push log files' updates to Telegram
Next-generation system shell
A cat(1) clone with wings.
A simple, fast and user-friendly alternative to find.
A colorized hexdump terminal utility.
Fast cp and rm commands
A cross-platform Rust rewrite of the GNU coreutils
Executes commands in response to file modifications
counts the lines of code
A simple text editor
A fast, extensible code editor written in Rust.
Vim-like text editor written in Rust
Command-line tools for querying, transforming and validating CSV data.
A fast and powerful docx to pdf rendering engine with Skia under the hood.
Find all your TODO notes with one command!
combines the usability of The Silver Searcher with the raw speed of grep
Intuitive find & replace CLI
Find files (ff) by name!
Read input lines as byte slices for high efficiency.
an efficient way to filter duplicate lines from unsorted input.
A Have I Been Pwned (HIBP) command-line utility tool that lets you easily check for compromised accounts and passwords.
A Command Line OTP (One Time Password) Authenticator application.
Simple timer for your terminal.
Project scaffolding tool, similar to Yeoman and Slush.
A command line tool to concatenate Amazon S3 files remotely using flexible patterns.
A command line tool to gather metadata about your Amazon S3 buckets.
A lightweight TUI app to view and query CSV files.
CLI that stars the GitHub repositories your project depends on across multiple ecosystems.
A dotfile and symlink manager that requires no configuration, inspired by GNU Stow's approach.
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!
A dice roll success distribution generator for tabletop homebrewers.
A lightning fast version of tmux-fingers written in Rust, copy/pasting tmux like vimium/vimperator.
Convert epoch to datetime and datetime to epoch
A lightweight fetch utility to show metadata about your rust project.
A privacy-focused, cross-platform screen region sharing tool for video calls
A simple CLI for streaming media files over a local network to UPnP media renderers
A lightweight virtual machine for container workload Firecracker Microvm
A containerization tool without daemons
QEMU Guest Agent-compatible agent for x86_64 Linux VMs on Cloud Hypervisor, reached over vsock and shipped as a single static binary
ActivityPub federating blogging application
A MITM Proxy Written in Rust 🦀! Toolkit for HTTP/1, HTTP/2, and WebSockets with SSL/TLS Capabilities.
A full-featured and easy-to-use web framework with the Rust programming language.
Host These Things Please — A basic http server for hosting a folder fast and simply
A small, self-contained cross-platform CLI tool that allows you to just grab the binary and serve some file(s) via HTTP
simple static http server
Mini reverse proxy server, HTTPS, CORS, static file hosting and template engine (minijinja)
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.
Rust lints
generates a changelog from git metadata (conventional changelog)
Set up a modern rust+react web app by running one command.
create ctags/etags for a cargo project and all of its dependencies
An API layer to build customer facing dashboards 10x faster
workspace productivity booster
The Git Commit Message and Changelog Generation Framework
[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
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.
A parallel universal-ctags wrapper for git repository
code completion for Rust
Web tool to evaluate rust regular expressions
A language server providing Rust code analysis and editor support.
the Rust toolchain installer
(crates.io) - Builds self-hosted static Rust API documentation from rustdoc JSON.
a basic task dependency tool emphasizing Rust functions over raw shell commands.
the Rust package manager
A utility to compare Rust micro-benchmarks
A cargo extension that can generate BitBake recipes utilizing the classes from meta-rust
inspect/manage/clean your cargo cache (~/.cargo//${CARGO_HOME}), print sizes etc
A wrapper around cargo rustc -- -Zno-trans which can be helpful for running a faster compile if you only need correctness checks
Generates binary Debian packages
run multiple cargo commands in a row
cargo extension that can generate ebuilds using the in-tree eclasses
allows you to add and list dependencies by reading/writing to your Cargo.toml file from the command line
queries crates.io for crates details from command line
A CLI tool for validating and managing lean Cargo package distribution archives by controlling which files are included in published crates.
A cargo subcommand to quickly view the licenses of all dependencies.
Cargo with less noise: warnings are skipped until errors are fixed, Neovim integration, etc.
Rust task runner and build tool.
A cargo plugin for showing a tree-like overview of a crate's modules.
runs specified cargo command on multiple crates
displays when newer versions of Rust dependencies are available, or out of date
tool for releasing git-managed cargo project, build, tag, publish, doc and push
lets people quickly and easily run Rust "scripts" which can make use of Cargo's package ecosystem
watches files changes, runs tests and notifies about the result with friendly OS notification
cargo subcommand for checking and applying updates to installed executables
A very simple third-party cargo subcommand to execute a custom command
Expand macros in your source code
focuses on improving the end-to-end experience of using Rust in resource-constrained environments and non-traditional platforms. See awesome-embedded-rust for a curated, and more extended list of embedded Rust resources.
effortless cross compilation of Rust programs to custom bare-metal targets like ARM Cortex-M
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.
^`^t Reusable components for the Arduino Uno.
A Rust bindings generator
use Java from Rust
use Rust from Java
Rust definitions corresponding to jni.h
uses JDBC from Rust
Safe Rust bindings to Lua 5.1
mruby safe bindings for Rust
use Rust from Node.js
Objective-C Runtime bindings and wrapper for Rust
Python bindings
Rust bindings for the Python interpreter
native Ruby extensions written in Rust
native Ruby extensions written in Rust and vice versa
package: :sparkles: pack up the wasm and publish it to npm!
A project for facilitating high-level interactions between wasm modules and JS.
Online IDE with full Rust support based on Rust Language Server
native support for rust and cargo since Version 3.22.2
Modal editor, faster as in less keystrokes, multiple selections, orthogonal design.
LSP client. Implemented in Rust and supports rls out of the box.
is a lightweight but powerful source code editor which runs on your desktop and is available for Windows, macOS and Linux. It comes with built-in support for JavaScript, TypeScript and Node.js and has a rich ecosystem of extensions for other languages (such as C++, C#, Java, Python, PHP, Go) and…
A fork of RustyCode
A tool used to evaluate the output of retrieval algorithms
A command-line benchmarking tool
A Performance Co-Pilot memory-mapped values instrumentation library
A stopwatch library
Compile-time assertions to ensure that invariants are met
A collection of JSON matchers for googletest-rust, supporting paths, arrays, and objects.
A source-level mutation testing framework (nightly only)
Mini Testing/Test-Driven Framework
HTTP mocking
property testing framework inspired by the Hypothesis framework for Python
A Rust implementation of QuickCheck
HTTP mocking
An RSpec inspired minimal testing framework for Rust
A Rust fuzzer, using AFL
A code coverage tool designed for Rust
An Extensible SystemVerilog simulator and verification engine.
C to Rust translator and cross checker built atop Clang/LLVM.
A utility to generate typescript types from rust code.
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.
Genetic Algorithm library. Implement a single trait for your problem and call a single method. Supports progress reporting, configurable parameters.
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.
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.
Execute genetic algorithm (GA) simulations in a customizable and extensible way.
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).
Evolutionary Algorithm Library for Rust. Without changes for 3 years.
Rust implementation of real-coded GA for solving optimization problems and training of neural networks.
A complete virtual-file-system based solution for agent memory, from extraction and search to automated optimization, and insights dashboard out-of-the-box.
Rust library for Self Organising Maps (SOM).
Open Machine Intelligence framework. . Abandoned project. The most updated fork is spearow/juice.
Machine learning crate for Rust.
Clean-room astronomical ephemeris and Vedic computation engine with JPL-validated positions, native Jyotish primitives, WebAssembly and Python bindings, and an MCP server.
A Rust port of the JavaScript library suncalc.
astronomy for Rust
Async-graphql is a high-performance server-side library that supports all GraphQL specifications.
A coroutine I/O library with a working-stealing scheduler
Scalable, coroutine-based, asynchronous IO handling library
Monad/MonadIO, Handler, Coroutine/doNotation, Functional Programming features for Rust
Zero-cost futures in Rust
MIO is a lightweight IO library for Rust with a focus on adding as little overhead as possible over the OS abstractions
rust stackful coroutine library
FMOD bindings
A simple library to play Sounds and Musics, on top of OpenAL and libsndfile
PortMidi bindings
A WAV encoding and decoding library
A Rust audio playback library
an aggregate of free and useful Audio, DSP and music libraries written in Rust.
PortAudio bindings
JSON Web Token lib in rust
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.
A CAN signal and definition parser
J2534 PassThru bindings
Rust DLT (Diagnostic Log and Trace) packet parser
[someip_parse] — A library for parsing the SOME/IP network protocol (without payload interpretation)
[can-dbc] — A parser for the DBC format
[tokio-socketcan-bcm] — Linux SocketCAN BCM support for tokio
[socketcan] — Linux SocketCAN library
[tokio-socketcan]] — Linux SocketCAN support for tokio based on the socketcan crate
[lin-bus] — LIN bus driver traits and protocol implementation
bioinformatics libraries in Rust.
Simple function caching/memoization
Memcached client library
Granular locking crate for Rust.
Support for parallelism and low-level concurrency in Rust
Low latency thread communication using the Disruptor pattern. Lower latency and higher throughput than Crossbeam but at a higher CPU cost.
[archery] — Library to abstract from Rc/Arc pointer types.
High performance, configurable and expressive parallel computation library.
Generic single-reader, multi-writer
A data parallelism library for Rust
Coroutine Library in Rust
A coroutine I/O library with a working-stealing scheduler
An AWS SDK for Rust
[fire] — Turn your function(s) to a command line app with one line of code
[clap] — A simple to use, full featured command-line argument parser
[structopt] — parse command line argument by defining a struct
[human-panic] — panic messages for humans
[copperline] — pure-Rust command line editing library
[liner] — A library offering readline-like functionality
[linefeed] — Configurable, extensible, interactive line reader
[rustyline] — readline implementation in Rust
[pager] — pipe your output through an external pager
[subprocess] — facilities for interaction with external pipelines
[duct] — A builder for subprocess pipelines and IO redirection
[rexpect] — automate interactive applications such as ssh, ftp, passwd, etc
[indicatif] — indicate progress to users
[pbr] — console progress bar for Rust
[spinners] — 60+ elegant terminal spinners
[terminal_cli] — build an interactive command prompt
[ansi_term] — control colours and formatting on ANSI terminals
[term-painter] — cross-platform styled terminal output
[termstyle] — build (and test) formatted and styled command line applications
[yansi] — A dead simple ANSI terminal color painting library
[crossterm] — crossplatform terminal library
[cursive] — build rich TUI applications
[term_grid] — Rust library for putting things in a grid
[termion] — bindless library for controlling terminals/TTY
[ratatui] — A library for building terminal user interfaces and the maintained successor to tui-rs.
[bear-lib-terminal] — BearLibTerminal bindings
[pancurses] — curses library, supports linux and windows
[rustbox] — bindings to Termbox
implementation of Brotli compression
Brotli decompressor in Rust that optionally avoids the stdlib
miniz bindings
snappy bindings
tar archive reading/writing in Rust
[argmin] — A pure Rust optimization library
[blas]
BLAS bindings
BLAS bindings
A C library for arbitrary precision arithmetic, operating on signed integers, rational numbers, and floating-point numbers. [LGPL3 & GPL2]
libgmp bindings
GSL bindings
LAPACK bindings
low-dimensional linear algebra library
Arrayfire bindings
An extensible, pluggable, backend-agnostic framework for parallel, high-performance computations on CUDA, OpenCL and common host CPU.
OpenCL bindings
scientific computing library in Rust
Robust statistical computation library in Rust
A rust optimization library which includes L-BFGS-B and Conjugate Gradient algorithm
A language for GPGPU numerical computing from a Rust macro
[config] — Layered configuration system for Rust applications (with strong support for 12-factor applications).
[configure_me] — library for processing application configuration easily
[cfg-rs] - A Configuration Library for Rust Applications
Web PKI TLS X.509 certificate validation in Rust.
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.
A Rust implementation of TLS
cryptographic algorithms in Rust
A Blockchain implementation
[exonum] — extensible framework for blockchain projects
A Rust implementation of TLS 1.2
Modular hash and crypto library in Rust
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.
[memsafe] — Locked, sealed, zero-on-drop memory for secrets.
Collection of cryptographic hash functions written in pure Rust
Pure Rust implementation of the Master Password password manager
Library providing several Attribute-Based Encryption (ABE) schemes
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.
Pure Rust implementation of the RNCryptor AES file format
[rooster] — Simple password manager to use in your terminal
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),...
Bindings for native TLS libraries
OpenSSL bindings
Bindings for Security Framework (macOS native TLS).
Bindings for Schannel (Windows native TLS)
CLI manager of one-time password generators aka Google Authenticator (TOTP)
generic connection pool
bindings to the DataStax C/C++ client
[couchdb] — A Rust client for the CouchDB REST API
an interface to CouchDB HTTP REST API for stable rust
[rs-es] — A Rust client for the Elastic REST API
A Rust client for the Elasticsearch REST API.
[etcd] — A client library for CoreOS's etcd.
ForestDB bindings
is an open source time series platform. This includes APIs for storing and querying data, processing it in the background for ETL or monitoring and alerting purposes, user dashboards, Internet of Things sensor data, and visualizing and exploring the data and more. It also has support for…
Synchronization interface
LevelDB bindings
[lmdb-rs] — LMDB bindings
Zero-config, single-file, embedded graph database with bi-temporal Datalog queries
Typed graph database where agents branch and merge like Git. S3-native, traversal + vector + BM25 in one runtime
[qldb] — AWS QLDB driver.
Redis library in Rust
A library that provides an embeddable, persistent key-value store for fast storage. oss
RocksDB bindings
A scalable, distributed, document-graph database in Rust
Self-contained, serverless, zero-configuration, transactional NoSQL engine. BSD-2-Clause
UnQLite bindings
ZooKeeper is a centralized service for maintaining configuration information, naming, providing distributed synchronization, and providing group services. (Source Code) Apache-2.0 Java/C++
[zookeeper] — A client library for Apache ZooKeeper.
a lightweight and simple key-value store, heavily inspired by Python's PickleDB.
A MySQL Proxy
[mysql_async] — asyncronous Rust Mysql driver based on Tokio.
[mysql] — A native MySql client
Fast client that supports MySQL, MariaDB and Percona databases.
[postgres] — A native PostgreSQL client
Sqlite3 bindings
an ORM and Query builder for Rust
A macro-free PostgreSQL and SQLite ORM for Rust with native binary JSONB and FTS5
an ORM for Rust
an async & dynamic ORM for Rust
A lightweight ORM library for Rust
N-dimensional array with array views, multidimensional slicing, and efficient operations
Dataframe structure and operations in Rust
High-performance runtime for data analytics applications
A generic framework for on-demand, incrementalized computation.
RisingWave is a cloud-native streaming database that uses SQL as the interface language.
[tst] — Ternary search tree collection
Extra iterator adaptors, functions and macros
Extension of Rust's std::collections
Array helpers for Rust. Some of the most common methods you would use on Arrays made available on Vectors. Polymorphic implementations for handling most of your use cases.
a hack to allow for arrays sized by typenums
[priority-queue] — A priority queue that implements priority changes.
Roaring Bitmaps in Rust
[rpds] — Persistent data structures in Rust.
Progress callbacks for types which implement dyn io::Read or dyn io::Write.
[usher] — Parameterized routing for generic resources in Rust.
A small charting/visualization tool and partial vega implementation
Data plotting library for Rust
Date and time library
[antimony] — stream processing / distributed computation platform
Easy Hadoop Streaming and MapReduce interfaces in Rust.
[rdkafka] — librdkafka bindings
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.
Beanstalkd bindings
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.
unofficial Rust library for SendGrid API
an SMTP-library for Rust
[mailparse] — A library for parsing real-world email files
A Rust ASN.1 (DER) serializer
Bencode implementation in Rust
I/O and binary data encoding for Rust
[goblin] — cross-platform, zero-copy, and endian-aware binary parsing
Supports big-endian, little-endian and native byte orders
Cap'n Proto is a type system for distributed systems
[encoding_rs] — A Gecko-oriented implementation of the Encoding Standard in Rust
Character encoding support for Rust. (also known as rust-encoding) It is based on WHATWG Encoding Standard, and also provides an advanced interface for error detection and recovery.
Rust implementation of CRC(16, 32, 64) with support of various standards
A fast and flexible CSV reader and writer, with support for Serde
An efficient cross platform serialization library
FlatBuffers compiler (flatc) integration for Cargo build scripts
A HTTP Archive Format (HAR) serialization & deserialization library
High-performance browser-grade HTML5 parser
encoding/decoding HTML entities
Amazon's Ion binary format encoder, decoder and hasher
[pikkr] — JSON parser which picks up values directly without performing tokenization in Rust
[serde_json] — JSON support for Serde framework
[simd-json] - High performance JSON parser based on a port of simdjson
[json] — JSON implementation in Rust
A pure Rust low/high level MessagePack implementation
[pem] — A Rust based way to parse and encode PEM-encoded data
A Postman Collection v1, v2 & v2.1 serialization & deserialization library
Rust implementation of Google protocol buffers
Rusty Object Notation
High performance XML pull reader/writer
an XML parser written in Rust
An XML library in Rust
An XPath library in Rust
A streaming XML library
Yet Another Serializer/Deserializer specialized for XML
libyaml bindings
Sorta Text Format in UTF-8
> UDisks2 DBus API
High level abstraction for the mount / umount2 system calls.
Absolute serializable path types and associated methods.
expanding opportunities standard library std::fs and std::io
temporary file library
[xattr] — list and manipulate unix extended file attributes
Allegro 5 bindings
[challonge] — Client library for the Challonge REST API. Helps to organize tournaments.
Specs Parallel ECS
A data-driven game engine built in Rust
A lightweight game framework for making 2D games with minimum friction
A Keep It Simple, Stupid 3D graphics engine written in Rust.
unrust — A pure rust based (webgl 2.0 / native) game engine
Vulkust — A safe, highly multithreaded, Vulkan based game engine written with Rust.
[sdl]
SDL1 bindings
SDL2 bindings
SFML bindings
[Victorem] — Easy UDP Game Server and UDP Client framework for creating simple 2D and 3D online game prototype
Voxlap bindings
geospatial tools and libraries written in Rust
A fast, offline reverse geocoder in Rust, inspired by https://github.com/thampiman/reverse-geocoder
[geomorph] — conversion between UTM, LatLon and MGRS coordinates
A pure Rust alternative to libraries like FreeType
safe OpenGL wrapper for the Rust language.
Rust alternative to GLFW
A Keep It Simple, Stupid 3D graphics engine written in Rust.
GLFW3 bindings and idiomatic wrapper
Generating PDF files in pure Rust
PDF writing library
PDF document manipulation
[vulkan]
[vulkano] —
A simple, cross-platform GUI automation library for Rust.
A declarative, cross-platform UI framework for Rust with virtual DOM, reactive signals, and HTML macros for WebAssembly.
A free, functional, IMGUI-oriented GUI framework for rapid development of desktop applications written in Rust, supported by the Mozilla WebRender rendering engine.
An easy-to-use, immediate-mode, 2D GUI library written entirely in Rust
Rust bindings to Core Foundation and other low level libraries on Mac OS X and iOS
Flutter is a framework to build high-performance, cross-platform mobile apps, allowing applications to be written for Android, iOS and Web Apps.
Build flutter desktop app in dart & rust.
Asynchronous, GTK+-based, GUI library, inspired by Elm
is a bloat-free graphical user interface library for C++. It outputs optimized vertex buffers that you can render anytime in your 3D-pipeline enabled application. It is fast, portable, renderer agnostic and self-contained (no external dependencies).
Rust bindings for ImGui
Another cross-platform widget toolkit. MIT
Clear Coat is a Rust wrapper for the IUP GUI library
IUP bindings
A simple UI framework built on IUP
Simple and portable (but not inflexible) GUI library in C that uses the native GUI technologies of each platform it supports. [MIT]
libui bindings . Abandoned project. The most updated fork is NoraCodes/libui-rs.
A single-header ANSI C gui library (archived)
Rust bindings for Nuklear
Official Qt documentation. Massive and comprehensive.
Integrate Qml and Rust by building the QMetaObject at compile time.
Binding generator hosted by KDE.
Qt bindings for Rust
nativefiledialog bindings
Sciter is an embeddable HTML/CSS/scripting engine aimed to be used as an UI layer of modern desktop applications. [Free/Commercial]
Sciter bindings
Perceptual image hashing and comparison for equality and similarity.
An implementation of HDR Radiance Estimation using Poisson Photon Noise Estimator for creating HDR image from a set of images
Basic imaging processing functions and methods for converting to and from image formats
An image processing library, based on the image library.
Low level 3D computer vision library in Rust
Rust bindings for OpenCV
[steganography] — A simple steganography library
A library for parsing Backus–Naur form context-free grammars.
Logging implementation for Rust
Structured, composable logging for Rust
highly configurable logging framework modeled after Java's Logback and log4j libraries
Macro for Python-esque list comprehensions in Rust.
A little macro for writing haskell-like do expressions without too much ceremony
CommonMark parser in Rust
iOS CocoaPods / Android JNI
A crate that allows Rust to be used to develop Pebble applications.
A synchronous HTTP client with a reqwest-like blocking API.
Scrape URLs from HTML pages
an FTP client for Rust
A library to work with IP networks in pure Rust
A Rust library for network simulation and testing
[futures-jsonrpc] — Futures implementation for JSON-RPC
A cross-platform, low level networking
A standalone, event-driven TCP/IP stack that is designed for bare-metal, real-time systems
A network application framework for rapid development and highly scalable production deployments of clients and servers.
Custom TCP/UDP protocol definitions
Actor library for Rust
nanomsg bindings
[Nng] — Nng (nanomsg v2) bindings
an NNTP client for Rust
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.
A POP3 client for Rust
libssh2 bindings
A modern SSH client built entirely in Rust.
an SSH library written from scratch in Rust, backed by libsodium
A STOMP 1.2 client implementation in Rust
ZeroMQ bindings
A Constrained Application Protocol(CoAP) library for Rust.
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.
parser combinator library
an URL parameter parser for rest filter inquiry
Parsing Expression Grammar (PEG) parser generator
A fast monadic-style parser combinator
parser combinator library
LR(1) parser generator for Rust
zero-allocation parsing of binary data
The Elegant Parser
A typed PEG parser generator (compiler plugin)
A query string parsing library for Rust inspired by https://github.com/ljharb/qs
JsonPath engine written in Rust. Webassembly and Javascript support too
declarative parsing engine that outputs a flat struct-of-arrays instead of an AST, with standalone per-type parsing methods, O(1) access, and benchmarks included
Library for reading and extracting debian archives
[serialport] — A cross-platform library providing access to serial ports.
Cross-platform information about the notebook batteries
Rust bindings to Linux Control Groups (cgroups)
> UDisks2 DBus API
Linux distribution installer library
inotify bindings
iptables bindings
Library to help you build window manager on linux
Unix-like API bindings
FUSE bindings
Windows API bindings
Rust implementation of a FreeBSD jail library
Rust bindings for the FreeBSD capsicum framework
[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…
Universal Robot Cobot Ethernet Communication API
A rusty dynamically typed scripting language
A small, statically-typed, functional programming language
A Lisp dialect functional programming language serving as a scripting and extension language for rust
A dynamically typed scripting language
A small extensible functional scripting language designed for concise expression with little code
A tiny and fast embedded scripting language resembling a combination of JS and Rust
Handlebars template engine with inheritance, custom helper support.
[askama] — A type-safe, compiled template engine inspired by Jinja.
HTML template system for Rust
template engine based on Jinja2 and the Django template language.
compile-time HTML templates
compile-time HTML templates
a Rust implementation of the Mustache spec
Compiler for Jade-like template language to cito.js-based virtual dom
Linear time suffix array construction (with Unicode support)
Elastic tab stops (i.e., text column alignment)
[textwrap] — Word wrap text (with support for hyphenation)
Construct n-grams from arbitrary iterators
A reader that allows forwards, backwards and random navigations through the lines of huge files without consuming iterators
Regular expressions (RE2 style)
String similarity metrics
Natural language detection library based on trigrams
Multilingual implementation of RAKE algorithm for Rust
[joinery] – Generic string + iterable joining
[simsearch] - A simple and lightweight fuzzy search engine that works in memory, searching for similar strings
[fst] —
[perlin] —
[SeekStorm] - sub-millisecond full-text search library & multi-tenancy server in Rust
[tantivy] —
Utilities for safely reinterpreting arbitrary byte sequences as native Rust types
Advanced Rust quantum computer simulator
CrOSVM - Enables Chrome OS to run Linux apps inside a fast, sercure virtualized environment
Hardware-accelerated virtualization on OS X
A Cargo subcommand for the client-side Web
A standard library for the client-side Web
Rust framework for making client web apps
A minimal Rust web framework for wasm in 800 lines of code
libcurl bindings
an HTTP implementation
an ergonomic HTTP Client for Rust.
Beautiful and elegant Yukikaze is little HTTP client library based on hyper.
Fast client that supports MySQL, MariaDB and Percona databases.
A lightweight async web framework for Rust with websocket support
A Pure Rust implementation of Branca for Authenticated and Encrypted API tokens.
A flexible web framework that does not sacrifice safety, security or speed.
A lightweight, high-performance, cross-platform Rust HTTP server library built on Tokio with built-in support for middleware, WebSocket, SSE, and raw TCP.
JSON Web Token implementation in Rust.
[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 template engine with inheritance, custom helper support.
A middleware-based server framework
inspired by Express
Rocket is web framework for Rust (nightly) with a focus on ease-of-use, expressability, and speed
A REST-like API micro-framework inspired by Grape and Hyper
A progressive web framework with low-level control, without the pain.
A lightweight web framework built on async hyper, implemented in Rust language.
Low level HTTP server library
Web framework in Rust
[tower-web] — A fast, boilerplate free, web framework for Rust
A framework for dealing with WebSocket connections (both clients and servers)
lightweight, event-driven WebSockets for Rust
Lightweight stream-based WebSocket implementation for Rust.
CLI for interacting with WebSockets, with functionality of Netcat, Curl and Socat.
[urlshortener] — A very simple urlshortener library for Rust.
A web framework intended for building maintainable, well-factored web apps.
[soup] - A library similar to Pythons BeautifulSoup, designed to enable quick and easy manipulation and querying of HTML documents.
A macro to embed static assets into a Rust binary.
[select] — A library to extract useful data from HTML documents, suitable for web scraping.
[sozu] — A HTTP reverse proxy.
[zola] — An opinionated static site generator with everything built-in.
Static site generator from markdown files.
[leven] — A simple, parallelized blog generator.
the Rust package manager
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.
Rust implementations for the The Computer Language Benchmarks Game
A set of WEB benchmarks available at https://c410-f3r.github.io/wtx-bench.
Describes the performance of all major database clients across different scenarios.
Presented by Julia Evans @ Rustconf 2016.
Presented by Michael Gattozzi @ RustConf 2017
Presented by Nicholas Matsakis @ C++Now 2018
A list of recommended resources voted by the programming community.
programming exercises that help you learn new concepts in Rust.
A peer-reviewed collection of articles/talks/repos which teach idiomatic Rust.
in-depth exploration of Rust's memory management rules, through implementing a few different types of list structures.
a collection of runnable examples that illustrate various Rust concepts and standard libraries.
A collection of simple examples that demonstrate good practices to accomplish common programming tasks, using the crates of the Rust ecosystem.
A video series by Carol Nichols and Jake Goulding (paid)
A collection of useful resources to learn Rust
small exercises to get you used to reading and writing Rust code
Learn these crates first as an extension to std
University of Pennsylvania's Comp Sci Rust Programming Course
Beginner, advanced, expert level Rust training material
A podcast about learning Rust
news on all things Rust
A catalogue of Rust design patterns, anti-patterns and idioms
Aaron Turon's blog posts on rust
list of RustBooks
A subreddit(forum) where rust related questions, articles and resources are posted and discussed
Awesome Rust libraries and hidden gems
vinta/awesome-python
The definitive list that answers "I want to do X in Python, which tool should I use?"
matteocrippa/awesome-swift
A collaborative list of awesome Swift libraries and resources. Feel free to contribute!
jaywcjlove/awesome-mac
This project is dedicated to collecting high-quality macOS software and organizing them systematically by different categories for easy search and use.
ziadoz/awesome-php
A curated list of amazingly awesome PHP libraries, resources and shiny things.
rockerBOO/awesome-neovim
Collections of awesome neovim plugins.
avelino/awesome-go
A curated list of awesome Go frameworks, libraries and software