Rust

A graph-oriented live coding language and audio DSP library written in Rust for real-time music creation and audio development.

A modern, configurable terminal-based MPD client with album art support via various terminal image protocols.

A cross-platform, terminal-based Spotify client written in Rust, offering a lightweight and keyboard-driven music experience.

A self-hosted music streaming server for enjoying your personal music collection from any device.

A fast, configurable terminal music player for Spotify with full feature parity, streaming, and audio visualization.

A lightweight, open-source Spotify client that runs as a UNIX daemon and supports Spotify Connect.

A terminal-based music and podcast player written in Rust, supporting local playback and downloads from various sources.

A framework providing developer tools for writing Solana programs (smart contracts) with Rust and TypeScript.

A simple, modular, and fast Rust framework for building MEV bots using an event-driven pipeline architecture.

A Rust-based compiler for Cairo, the Turing-complete language for creating provable programs for general computation.

An EVM-compatible decentralized storage network secured by EigenLayer, offering verifiable storage for AI data and Web3 applications.

A decentralized, programmable distributed ledger providing a global financial infrastructure.

A blazing fast, portable, and modular toolkit for Ethereum application development written in Rust.

A minimal implementation of the Mimblewimble blockchain protocol, focusing on privacy and scalability.

An open-source Ethereum consensus client written in Rust, designed for security and performance on the Ethereum proof-of-stake network.

A decentralized blockchain infrastructure for highly scalable, secure, low-latency Web3 applications.

Reference client implementation of the NEAR Protocol blockchain, enabling scalable, user-friendly decentralized applications.

A comprehensive SDK for building interoperable blockchains on the Polkadot network, including Substrate, FRAME, Cumulus, and XCM.

A modular, high-performance Ethereum full node implementation written in Rust, designed for speed and developer flexibility.

A high-performance Rust implementation of the Ethereum Virtual Machine (EVM) used by major clients, tooling, and Layer 2 solutions.

A Rust library for Bitcoin protocol data structures, serialization, parsing, and network message handling.

A next-generation smart contract platform with high throughput, low latency, and an asset-oriented programming model powered by Move.

A privacy-focused cryptocurrency that uses zero-knowledge proofs to enable shielded transactions with full anonymity.

An Adobe Flash Player emulator written in Rust that runs on desktop and web via WebAssembly.

A high-level emulator written in Rust that runs early iPhone OS 2.x and 3.x games on modern desktops and Android.

A terminal file manager that provides a fast, interactive way to navigate directories, search files, and manage your filesystem.

A ranger-like terminal file manager written in Rust, offering fast navigation and file operations.

An open-source cross-platform file manager powered by a virtual distributed filesystem, unifying files across devices and clouds.

A hackable, minimal, fast terminal UI file explorer that orchestrates command-line utilities.

A blazing fast terminal file manager written in Rust with full async I/O and extensive customization.

An open-source, multi-player city simulation game focusing on realism, collaborative planning, and microscopic detail simulation.

A Doom 1 & 2 renderer written in Rust, featuring a modern OpenGL 3+ pipeline and 100% safe code.

Generate detailed Minecraft worlds from real-world geography and architecture using OpenStreetMap and elevation data.

A cross-platform backup tool for PC video game save data, supporting over 19,000 games and multiple game stores.

A multithreaded lossless PNG/APNG compression optimizer written in Rust, usable via CLI or as a library.

An open-source raster to vector graphics converter that efficiently transforms images into compact SVG files.

A Rust-based middleware framework for building low-latency, composable, and distributed AI robotic applications using dataflow graphs.

A unified messaging engine built in Rust that supports MQTT, Kafka, NATS, AMQP, and mq9 protocols on a single shared storage layer.

An open-source LLMOps platform unifying gateway, observability, evaluation, optimization, and experimentation for industrial-grade LLM applications.

An open-source observability platform for logs, metrics, traces, and frontend monitoring with 140x lower storage costs and single binary deployment.

A cloud-native search engine optimized for observability data like logs and traces, offering sub-second search on cloud storage.

A metrology agent for measuring electric power and energy consumption of tech services, enabling sustainability-focused decisions.

A high-performance, end-to-end observability data pipeline for collecting, transforming, and routing logs and metrics.

Asterinas is a production-grade, memory-safe Linux alternative built from the ground up in Rust with a modern framekernel architecture.

A Unix-like, Linux-compatible kernel written in Rust with an asynchronous core and modular architecture.

A modern operating system written in Rust that explores intralingual design, shifting OS responsibilities like resource management into the compiler.

A secure embedded operating system for microcontrollers that runs multiple concurrent, mutually distrustful applications on Cortex-M and RISC-V platforms.

An open-source payments switch written in Rust that provides modular, composable infrastructure for fast, reliable, and affordable payment processing.

A terminal session manager for AI coding agents that runs multiple agents in parallel using tmux and git worktrees.

A command-line interface tool that integrates multiple LLM providers, offering shell assistance, interactive chat, RAG, AI tools, and local server capabilities.

A CLI tool for structural code search, linting, and rewriting using abstract syntax trees, written in Rust.

A privacy-first, cross-platform text expander that replaces keywords with text, images, or scripts across any application.

A desktop app to manage and switch between configurations for Claude Code, Codex, Gemini CLI, OpenCode, and OpenClaw.

A lightweight LDAP authentication server with a web UI, designed for simple user management in self-hosted environments.

A CLI tool that simplifies Git worktree management, specifically designed for running multiple AI coding agents in parallel.

An open-source AI memory tool that captures your screen and audio locally, enabling search and automation agents based on your computer activity.

A modular Rust library for building fast, scalable, and customizable fuzzers that work across multiple platforms and instrumentation backends.

A cross-platform terminal UI network monitor providing real-time connection tracking, deep packet inspection, and process attribution.

A Rust tool for detecting IMSI catchers (cell-site simulators) on mobile hotspots like the Orbic RC400L.

A fast, simple, recursive content discovery tool written in Rust for forced browsing attacks.

A semi-automatic OSINT framework and package manager for gathering intelligence and enumerating attack surfaces.

A modern, fast port scanner with a scripting engine and adaptive learning, capable of scanning all 65k ports in 3 seconds.

A smarter cd command that learns your most-used directories for fast navigation across all major shells.

Atuin replaces your shell history with a SQLite database, adding context and optional encrypted sync across machines.

A terminal utility that displays real-time network bandwidth usage by process, connection, and remote IP/hostname.

A customizable cross-platform graphical process and system monitor for the terminal.

McFly replaces your shell's ctrl-r history search with an intelligent neural network-powered engine that prioritizes commands based on context.

A modern, feature-rich replacement for the ps command, written in Rust, with colored output and advanced process information.

A terminal-based disk space navigator that visualizes storage usage with interactive treemaps.

A more intuitive disk usage analyzer written in Rust that visualizes which directories and files consume the most space.

A modern, feature-rich replacement for the ls command with better defaults, Git integration, and hyperlink support.

A Git extension that automatically tracks AI-generated code, linking each line to the agent, model, and original transcripts.

A modern Git-based version control client with GUI and CLI, designed for AI-powered workflows and enhanced branch management.

A blazing fast terminal user interface for Git, written in Rust, offering GUI-like comfort directly in your terminal.

An extensible SQL-like query language and SDK for querying .git files and other data sources with full SQL feature support.

Interactive CLI tool to browse, search, and restore file versions from ZFS/btrfs/nilfs2 snapshots, Time Machine, and Restic backups.

A tool that cleans dependency directories and build artifacts from projects across 20+ programming languages and frameworks.

A Linux tool for monitoring and configuring AMD, Nvidia, and Intel GPUs, including overclocking, fan control, and power management.

A modern, feature-rich rewrite of the GNU ls command with icons, colors, and tree view.

A binary file analysis tool that colorizes and displays internal structures of ELF, Mach-O, PE, and archive formats.

A terminal-based network scanner and diagnostic tool with a modern TUI for WiFi scanning, packet analysis, and port scanning.

A modern, cross-platform shell that treats data as structured tables instead of plain text.

A terminal-based Linux kernel manager and activity monitor for loading, unloading, and monitoring kernel modules.

A fast, user-friendly CLI tool for compressing and decompressing multiple archive formats in the terminal.

A fast, memory-efficient command-line tool for finding and removing duplicate files with advanced filtering options.

A command-line task management tool for sequential and parallel execution of long-running shell commands.

A multi-platform desktop utility to find and remove unnecessary files like duplicates, empty folders, similar images, and more.

A modern system shell written in Rust with a simple yet powerful syntax, designed for performance and security.

A cat clone with syntax highlighting, Git integration, and automatic paging.

A simple, fast, and user-friendly command-line tool to find files and directories, designed as an alternative to the traditional 'find' command.

A command-line hex viewer with colored output to distinguish different byte categories.

A fast and versatile fuzzy finder written in Rust, designed to quickly navigate files, lines, and commands.

A network diagnostic tool combining traceroute and ping for analyzing network issues with a real-time TUI.

A cross-platform Rust reimplementation of the GNU coreutils, aiming for drop-in compatibility with improved performance and error messages.

A standalone tool that watches files and runs commands automatically when modifications are detected.

A fast and accurate command-line tool that counts lines of code, comments, and blanks across over 150 programming languages.

An interactive terminal-based JSON viewer and jq filter editor with syntax highlighting and auto-completion.

A fork of Emacs that adds modern features like TypeScript/JavaScript support via Deno, GPU-accelerated rendering with WebRender, and improved async I/O.

A modern, zero-configuration terminal text editor with IDE-level features and familiar keybindings.

A terminal-based text editor written in Rust, designed for speed, extensibility, and cross-platform use.

A Kakoune/Neovim-inspired modal text editor written in Rust, featuring multiple selections and built-in language server support.

A configurable terminal text editor written in Rust with UTF-8 support, syntax highlighting, and a strict 1024-line code limit.

A lightning-fast, modal code editor with built-in LSP support and remote development capabilities, written in Rust.

A lightweight, configurable terminal-based text editor built from scratch with a plugin system and Lua configuration.

A high-performance, multiplayer code editor built by the creators of Atom and Tree-sitter.

A cinematic Git commit replay tool for the terminal, turning your Git history into a living, animated story.

A terminal tool to run and manage multiple commands in parallel with separate output panes and interactive controls.

A terminal user interface (TUI) for viewing and managing Docker containers.

An open-source remote desktop application designed for self-hosting, as an alternative to TeamViewer.

A fast, encrypted, and deduplicated backup tool written in Rust, compatible with restic repositories.

WiFi DensePose turns commodity WiFi signals into real-time human pose estimation, vital sign monitoring, and presence detection without cameras.

A Rust implementation of the age file encryption tool, offering simple, secure encryption with small explicit keys and UNIX-style composability.

A lightweight TUI application for viewing and querying tabular data files like CSV, Parquet, and JSON with SQL support.

A fast, portable, and hackable fuzzy finder for the terminal that searches files, text, git repos, and custom data sources.

Unofficial Bitwarden-compatible password manager server written in Rust, optimized for self-hosted deployment.

Offline audio/video transcription desktop app using OpenAI Whisper with privacy-focused local processing.

Warp is a modern terminal and agentic development environment built for coding with multiple AI agents.

Expose your local web server to the internet with a public URL, written in Rust with async-io.

A self-hostable, decentralized link aggregator and forum for the fediverse, similar to Reddit.

A federated blogging engine built with Rust and ActivityPub, allowing users to create and manage multiple blogs across interconnected instances.

A private, fast, and lightweight front-end for Reddit written in Rust, with no JavaScript, ads, or tracking.

The backend services and libraries powering the Stoat chat platform, built in Rust.

A Rust framework for building fast, reliable, and programmable networked systems and HTTP proxies.

A cross-platform, high-performance asynchronous web server for serving static files, built with Rust.

A fast, self-contained CLI tool to serve files and directories over HTTP with zero configuration.

A fast, feature-rich static file server written in Rust with directory listing, upload, HTTPS, and SPA support.

A cargo subcommand for installing Rust binaries from pre-built artifacts instead of building from source.

A developer tool to quickly create new Rust projects using git repositories as templates.

A Cargo subcommand to find unused dependencies in Rust projects' Cargo.toml files.

A Cargo subcommand to show the result of Rust macro expansion and #[derive] expansion for debugging.

A fast, hermetic, multi-language build system designed for large-scale projects and distributed compilation.

A blazing fast build tool for Rust that compiles up to 5x faster than cargo.

A scalable build system for monorepos with support for multiple programming languages and frameworks.

A fast Rust-based JavaScript/TypeScript bundler with Rollup-compatible API, intended for Vite's future bundler.

A Nix-powered, high-performance build cache and remote execution server compatible with Bazel, Buck2, and other RE build systems.

A browser-based frontend to gdb (GNU debugger) for C, C++, Go, Rust, and Fortran debugging.

Docker images for compiling static Rust binaries using musl-libc, with static C libraries for openssl, diesel, and sqlx.

A cargo subcommand that speeds up Rust Docker builds by caching dependencies using Docker layer caching.

An open-source tool for building and deploying software across unlimited servers with no business edition restrictions.

A Rust-based keyboard firmware library supporting layers, macros, real-time keymap editing, wireless BLE, and split keyboards.

A comprehensive guide to cross-compiling Rust programs, covering setup, toolchains, and troubleshooting for various target architectures.

A Rust crate providing safe, convenient, and performant abstractions for UEFI (Unified Extensible Firmware Interface) development.

A Rust-based downstream fork of coreboot, designed as a modern firmware implementation for booting LinuxBoot payloads.

Generates C and C++11 headers from Rust libraries that expose a public C API.

A safe, zero-overhead FFI bridge for calling C++ code from Rust and Rust code from C++.

Automatically generates Rust FFI bindings to C and C++ libraries.

A safe Rust library for creating Erlang NIFs that prevents crashes in the BEAM VM.

Safe, high-level Rust bindings for Lua 5.1-5.5, LuaJIT, and Luau with async/await support.

Rust bindings for writing safe and fast native Node.js modules.

A modern ISO Prolog implementation written in Rust, aiming to be an industrial-strength production environment and research testbed.

Rust bindings for the Python interpreter, enabling Rust code to call Python and Python to call Rust.

Rust bindings for Python, enabling creation of native Python extension modules and embedding Python in Rust binaries.

A Python 3 interpreter written in Rust, enabling Python execution in WebAssembly, embedding, and more.

A Rust library and CLI tool for high-level interoperability between WebAssembly modules and JavaScript.

A one-stop tool for building Rust-generated WebAssembly packages that interoperate with JavaScript in browsers or Node.js.

An extremely fast Python linter and code formatter written in Rust, offering drop-in replacements for tools like Flake8 and Black.

A pluggable and configurable code formatting platform written in Rust that unifies all your formatters in one tool.

A tool for formatting Rust code according to the official Rust style guidelines.

A deprecated open-source Rust plugin for IntelliJ-based IDEs, providing language support, Cargo integration, and debugging features.

A lightning-fast, modal code editor with built-in LSP support and remote development capabilities, written in Rust.

Language Server Protocol (LSP) client plugin for Vim and Neovim, providing IDE-like features for multiple programming languages.

A Vim plugin providing Rust file detection, syntax highlighting, formatting, and integration with tools like Syntastic and rustfmt.

A statistics-driven microbenchmarking library for Rust that provides rigorous performance analysis.

A high-performance memory profiler for Linux that captures every allocation and deallocation with full stack traces.

A command-line benchmarking tool that performs statistical analysis across multiple runs to accurately measure and compare shell command execution times.

A tool for statically verifying the correctness of Rust code using formal specifications and automated solvers.

A powerful mock object library for Rust that generates mock implementations of traits and structs for unit testing.

A Rust library for fuzzing Rust code with AFLplusplus to find security and stability issues.

Transpile trained machine learning models into native code (Java, C, Python, Go, etc.) with zero dependencies.

A transpiler that migrates C99-compliant code to unsafe Rust, preserving functionality and enabling incremental refactoring.

An automatic semantics-preserving translator that converts C source code into equivalent Rust syntax.

A modern, simple TCP tunnel in Rust that exposes local ports to a remote server, bypassing NAT firewalls.

A lightweight, high-performance reverse proxy written in Rust for secure NAT traversal and exposing local services to the internet.

A fast, low-level I/O library for Rust providing non-blocking APIs and event notification for high-performance applications.

A foundational library for zero-cost asynchronous programming in Rust, providing traits, combinators, and utilities.

A runtime for writing reliable, asynchronous, and slim applications with the Rust programming language.

A high-performance Rust library for stackful coroutines, providing Goroutine-like concurrency for massive concurrent programs.

A pure Rust library for demuxing media formats, reading metadata tags, and decoding audio codecs.

A cross-platform, low-level audio input and output library written in pure Rust.

A Rust audio playback library with a simple API, supporting multiple audio formats through optional decoders.

A Rust library for encoding and decoding JSON Web Tokens (JWT) with support for multiple algorithms and flexible validation.

A Rust library providing caching structures and procedural macros for easy function memoization.

A high-performance, concurrent caching library for Rust inspired by Java's Caffeine.

A ccache-like compiler wrapper that caches compilation outputs locally or in remote storage to speed up build times.

A Rust runtime and libraries for building and deploying AWS Lambda functions.

Official AWS SDK for Rust, providing idiomatic Rust APIs for AWS services with async support and code generation from Smithy models.

A comprehensive AWS SDK for Rust, providing idiomatic Rust APIs for interacting with Amazon Web Services.

An open-source abstraction layer library that simplifies application deployment on AWS, GCP, Azure, and other cloud providers.

A full-featured, fast command-line argument parser for Rust applications.

A Rust derive-based argument parser optimized for code size and Fuchsia command-line tool conformance.

Parse command line arguments by defining a struct in Rust, combining clap with custom derive.

A Rust library for pretty printing tables of structs and enums with extensive styling and formatting options.

A Rust library that provides human-friendly panic messages for command-line applications.

A cross-platform readline implementation in Rust with Emacs/vi keybindings, history, and completion.

A Rust library for adding progress bars, spinners, and color support to command-line applications.

A Rust library for building interactive, customizable prompts in terminal applications.

A simple Rust library for coloring terminal output with an intuitive API and support for true colors.

A Rust library for building interactive command-line prompts and dialogs with a user-friendly interface.

A TUI (Text User Interface) library for Rust to build rich terminal applications.

A Rust crate for building terminal user interfaces (TUIs) with a simple and flexible API.

A pure Rust, bindless library for low-level terminal handling, manipulation, and reading.

A pure-Rust library for cross-platform terminal manipulation, enabling rich text-based interfaces.

A write-once-run-anywhere GPGPU library for Rust that abstracts WebGPU for CUDA-like compute with portability across desktop, mobile, and browser.

A comprehensive linear algebra library for Rust with support for statically-sized and dynamically-sized matrices.

A pure Rust linear algebra library focusing on portability, correctness, and performance with both low-level routines and high-level wrappers.

A Rust library providing a comprehensive toolkit of concurrent data structures, synchronization primitives, and memory management utilities.

A lightweight data-parallelism library for Rust that makes it easy to convert sequential computations into parallel ones.

A layered configuration system for Rust applications with strong support for 12-factor applications.

A Rust cryptography library derived from BoringSSL, designed as an experimental alternative to OpenSSL.

A high-level cryptographic library providing secure data storage, messaging, and session encryption with unified APIs across 14+ platforms.

OpenSSL bindings for Rust providing cryptographic functionality and TLS/SSL support.

A collection of cryptographic hash functions implemented in pure Rust, designed for interoperability and no_std environments.

A modern, memory-safe TLS library written in Rust, implementing TLS 1.2 and 1.3 for clients and servers.

An ultra-performant data transformation framework for AI, with incremental processing and data lineage built-in.

An extensible SQL query engine written in Rust, using Apache Arrow as its in-memory format for building fast database and analytic systems.

A modern spreadsheet engine written in Rust for programmatic spreadsheet manipulation across diverse environments.

A Python ETL framework for stream processing, real-time analytics, and building live LLM/RAG pipelines, powered by a scalable Rust engine.

A PostgreSQL extension that brings Elastic-quality full-text search and analytics directly inside Postgres.

An extremely fast query engine for DataFrames, written in Rust, with multi-language frontends.

A language and runtime that optimizes performance of data-intensive applications by lazily building and optimizing computations across libraries.

A distributed stream processing engine in Rust that performs stateful computations on real-time data with subsecond results.

A distributed data streaming engine with stateful stream processing for building responsive data-intensive applications.

A persistent message streaming platform built in Rust for ultra-low latency and high throughput, supporting multiple transport protocols.

A portable mixed-precision math library with 2,000+ SIMD kernels for 15+ numeric types across x86, Arm, RISC-V, and WebAssembly.

A Rust procedural macro for creating newtypes with built-in sanitization and validation guarantees.

A Rust library providing fully persistent data structures with structural sharing.

A Rust library providing extra iterator adaptors, methods, free functions, and macros for more expressive iteration.

A Rust drawing library for high-quality data plotting with support for both WASM and native applications.

An open-source SDK for logging, storing, querying, and visualizing multimodal, time-series data like images, point clouds, and tensors.

An open-source headless CMS and real-time database with a powerful table editor, full-text search, and SDKs for JS/React/Svelte.

A transactional, relational-graph-vector database that uses Datalog for query, designed as the hippocampus for AI.

An open-source enterprise data warehouse built in Rust for AI agents, analytics, vector search, and full-text search.

A distributed SQL database in Rust, built from scratch as an educational project to illustrate core database concepts.

An S3-compatible distributed object storage service designed for small-to-medium scale self-hosted geo-distributed deployments.

A Rust library that provides a SQL database engine with a parser, execution layer, and pluggable storage for structured and unstructured data.

An open-source observability database that unifies metrics, logs, and traces into a single engine, replacing Prometheus, Loki, and Elasticsearch.

An open-source graph-vector database built in Rust that unifies application data, vectors, and graphs for AI applications.

An open-source embedded retrieval library for multimodal AI, offering fast vector search, SQL, and full-text search.

A real-time data integration platform that creates and continually updates consistent views of transactional data using SQL.

An open-source serverless Postgres platform that separates storage and compute for autoscaling, branching, and scale-to-zero.

A streaming data-flow system that acts as a fast storage backend for read-heavy web applications by precomputing and caching relational query results.

A SPARQL graph database written in Rust, providing compliant, safe, and fast RDF data storage and querying.

The official MongoDB driver for Rust, providing async and sync APIs to interact with MongoDB deployments.

A PostgreSQL extension that brings Elastic-quality full-text search and analytics directly inside Postgres.

A PostgreSQL proxy written in Rust that provides connection pooling, load balancing, and database sharding.

A high-performance vector database and search engine written in Rust, designed for AI applications with filtering and payload support.

An embedded key-value database in pure Rust with ACID transactions and high performance.

Enterprise-grade event streaming platform that continuously ingests, processes, and serves real-time data with Apache Iceberg™ integration.

A high-performance, S3-compatible distributed object storage system built in Rust, optimized for data lakes and AI workloads.

A high-level Redis, Valkey, and RESP-compliant database client library for Rust with flexible type conversion.

A self-learning vector database with graph intelligence, local AI, and PostgreSQL integration, built for real-time adaptation.

A Redis-compatible in-memory data store re-implemented in Rust for cross-platform use and multi-core performance.

A Rust wrapper for Facebook's RocksDB embedded key-value storage engine.

A modern scalable NoSQL database with BlueQL, designed for performance, scalability and flexibility.

A scalable, distributed, collaborative, document-graph database for the realtime web, built in Rust.

SQLSync is a collaborative offline-first wrapper around SQLite that synchronizes web application state between users, devices, and the edge.

An embedded, serverless, transactional NoSQL database engine with key/value and JSON document store capabilities.

A distributed, transactional key-value database built in Rust, offering ACID compliance and horizontal scalability.

An embedded database for serverless and edge runtimes, storing data as Parquet on S3 with stateless compute.

An open, sub-millisecond, single-executable Firebase alternative with type-safe APIs, built-in WebAssembly runtime, realtime subscriptions, auth, and admin UI.

Turso is an in-process SQL database written in Rust, compatible with SQLite, offering async I/O, vector search, and multi-language support.

A fast, single-file similarity search and clustering engine for vectors and arbitrary objects with multi-language bindings.

A safe, extensible ORM and Query Builder for Rust that eliminates boilerplate and runtime errors without sacrificing performance.

A high-performance Rust ORM framework with compile-time dynamic SQL compilation for zero-runtime-overhead database operations.

A powerful, async relational ORM for Rust with advanced relations, nested persistence, and GraphQL integration.

A generic, database-agnostic connection pool implementation for Rust applications.

A dynamic SQL query builder for Rust that supports MySQL, PostgreSQL, and SQLite with a unified API.

Native PostgreSQL driver for Rust with synchronous and asynchronous client options.

Ergonomic Rust bindings for SQLite, providing a safe and convenient API for database operations.

A Rust datetime library focused on correctness and ease of use, with seamless time zone database integration.

A timezone-aware date and time library for Rust with configurable parsing, formatting, and correct calendar operations.

A fully asynchronous, futures-based Apache Kafka client library for Rust built on librdkafka.

Orchestrate end-to-end encryption, cryptographic identities, mutual authentication, and authorization policies between distributed applications at scale.

A pure-Rust eBPF library focused on developer experience, operability, and compile-once-run-everywhere capabilities.

A Rust library for sending emails with multiple transport methods, SMTP security, and async support.

A Rust tool to verify email address deliverability without sending emails, with CLI, HTTP backend, and library options.

A compact binary serialization format implementation for Rust with zero-copy deserialization support.

A Rust implementation of Cap'n Proto, enabling zero-copy serialization and RPC for high-performance distributed systems.

A fast and flexible CSV reader and writer for Rust with Serde support for easy data serialization.

A high-performance, browser-grade HTML5 parser written in Rust, developed as part of the Servo project.

A strongly typed JSON serialization and deserialization library for Rust, part of the Serde framework.

A pure Rust implementation of Google Protocol Buffers for generating and serializing structured data.

A Protocol Buffers implementation for Rust that generates simple, idiomatic Rust code from .proto files.

A zero-copy deserialization framework for Rust that enables high-performance data serialization without copying.

A readable data serialization format for Rust that resembles Rust syntax and supports Serde's data model.

A comprehensive TOML toolkit written in Rust, providing parsing, formatting, validation, and language server support.

An open data access layer that provides a unified API for interacting with diverse storage services across any language.

A zero-details, privacy-focused in-app file system that encrypts files and directories into a secure repository.

A comprehensive Rust library for quantitative finance, offering pricing models, risk analysis, and financial data tools.

A production-grade Rust-native trading engine with deterministic event-driven architecture for multi-asset, multi-venue systems.

A terminal-based stock ticker application that displays real-time financial data from Yahoo! Finance.

A modular Rust toolkit for building roguelikes and terminal-based games with multiple rendering backends.

A parallel Entity-Component System (ECS) library for Rust, designed for high flexibility and performance.

A high-performance, feature-rich Entity Component System (ECS) library for Rust game development with minimal boilerplate.

A refreshingly simple, data-driven game engine built in Rust, offering a complete 2D and 3D feature set.

A lightweight cross-platform Rust game framework for creating 2D and 3D games with minimal friction.

A simple 3D and 2D graphics engine for Rust designed for minimal friction when drawing geometric figures.

Rust bindings for the Godot 3 game engine, enabling game development with Rust's type safety and performance.

A high-performance, memory-efficient Minecraft server implementation written in Rust, compatible with vanilla 1.21.8 clients.

A high-performance Minecraft server implementation written in Rust, offering fast, efficient, and customizable hosting.

Rust bindings for SDL2, providing safe and idiomatic access to multimedia libraries for game development and interactive applications.

A blazing fast tile server and toolset for generating and serving vector tiles from PostGIS, MBTiles, and PMTiles.

A fast, flexible graph data structure library for Rust with multiple graph types and built-in algorithms.

An open-source vector-based drawing app for sketching, handwritten notes, and document annotation.

A low-level, cross-platform graphics and compute abstraction library for Rust with a Vulkan-like API.

Convert ASCII diagram scribbles into clean, scalable SVG graphics.

A cross-platform, safe, pure-Rust graphics API that runs natively on Vulkan, Metal, D3D12, OpenGL, and WebGPU.

A fast, portable, and safe SVG rendering library written in Rust, supporting static SVG files.

A safe, high-level OpenGL wrapper for Rust that provides an elegant API while handling error-prone OpenGL details.

An IDE for interactive AI image and video creation, turning prompting into intentional crafting for artists and filmmakers.

A Rust library for creating, merging, modifying, and decrypting PDF documents with support for modern object streams.

A safe and rich Rust wrapper around the Vulkan graphics API, preventing invalid usage through compile-time and runtime checks.

A fullstack Rust framework for building cross-platform apps (web, desktop, mobile) with a single codebase.

An easy-to-use immediate mode GUI library for Rust that runs on both web and native platforms.

Rust bindings for the FLTK GUI library, enabling cross-platform, lightweight, and fast desktop applications.

A framework for building cross-platform apps with Rust business logic and Flutter UI, using native FFI for efficient communication.

Build Flutter desktop applications with Rust backend integration for high-performance native functionality.

A feature-rich, seamless binding generator for calling Rust code from Flutter/Dart and vice versa.

A free, functional, reactive GUI framework for building native desktop applications in Rust, C, and C++.

Complete Rust bindings for GTK 4, enabling native GUI application development with Rust.

A cross-platform GUI library for Rust focused on simplicity, type-safety, and a reactive programming model inspired by Elm.

Rust bindings for Dear ImGui, enabling immediate mode GUI development in safe Rust.

A portable C library for creating native GUI applications on Windows, Unix (GTK+), and macOS.

A Rust library providing 60+ cross-platform desktop UI components for building modern applications with the GPUI framework.

An AI-accelerated Rust platform for building native and web apps with a live-editable UI DSL and GPU-accelerated rendering.

A cross-platform Rust UI toolkit based on the Entity Component System pattern with a functional reactive-like API.

An easy-to-use, 2D GUI library written entirely in Rust.

A Rust GUI framework for building multi-platform applications with a non-intrusive, data-driven approach.

A declarative GUI toolkit for building native user interfaces across embedded, desktop, and mobile platforms using Rust, C++, JavaScript, or Python.

Build smaller, faster, and more secure desktop and mobile applications using web technologies.

A cross-platform WebView rendering library in Rust for building desktop and mobile applications.

An experimental Rust architecture for reactive UI, providing a high-level framework and foundational toolkit for native GUI apps.

A pure Rust library for encoding, decoding, and processing images in many common formats.

Rust bindings for the OpenCV computer vision library, enabling Rust developers to leverage OpenCV's capabilities.

A lightweight logging facade library for Rust that provides a unified API while allowing flexible backend implementations.

A structured, extensible, and composable logging ecosystem for Rust.

A framework for instrumenting Rust programs to collect structured, event-based diagnostic information.

A Rust crate for generating compile-time-checked builders for structs and functions with named parameters and optional arguments.

A fast, safe, and versatile pull parser for CommonMark and GitHub Flavored Markdown, written in Rust.

A native gRPC client & server implementation for Rust with async/await support, built on hyper and tokio.

A Rust wrapper for gRPC Core providing high-performance RPC with async support and HTTP/2.

A command line tool to run and test HTTP requests using a simple plain text format.

Actor framework for Rust providing a high-level API for building concurrent, distributed systems.

A cross-platform Rust library for low-level network packet manipulation and protocol implementation.

A standalone, event-driven TCP/IP stack for bare-metal, real-time systems written in Rust.

A set of Rust libraries implementing the MQTT standard, including a high-performance broker and an easy-to-use client.

A Rust implementation of the libp2p modular networking stack for building peer-to-peer applications.

A modular networking stack in Rust that enables connections by public key instead of IP addresses, with automatic hole-punching and relay fallback.

A Rust implementation of the QUIC transport protocol and HTTP/3, providing low-level APIs for building high-performance networking applications.

A Rust implementation of QUIC, HTTP/3, and QPACK used by Mozilla Firefox, providing a library and command-line tools.

A pure-Rust, async-compatible implementation of the IETF QUIC transport protocol.

A zero-overhead protocol that unifies data in motion, at rest, and computations via pub/sub, geo-distributed storage, and queries.

A Parsing Expression Grammar (PEG) parser generator for Rust that builds recursive descent parsers from concise grammar definitions.

A Rust parser generator framework focused on usability, offering compact, readable grammars with LR(1) parsing.

A general-purpose parser for Rust using Parsing Expression Grammars (PEG) with a focus on accessibility, correctness, and performance.

A Rust parser combinator framework for building fast, safe, and memory-efficient parsers for binary and text formats.

A parser generator tool and incremental parsing library for building syntax trees in programming tools.

Rust-friendly bindings to *nix platform APIs (Linux, Darwin, etc.) with safe abstractions over libc.

Safe Rust bindings to POSIX/Unix/Linux/Winsock syscalls with memory safety, I/O safety, and configurable backends.

Comprehensive Rust FFI bindings to the entire Windows API, enabling native Windows development in Rust.

An embeddable JavaScript engine written in Rust, supporting over 90% of the ECMAScript specification.

A small, statically-typed, functional programming language designed for embedding in Rust applications.

A constraint-based record and functional language for writing, validating, and managing complex configurations, especially in cloud-native scenarios.

An embeddable polyglot runtime for calling functions between multiple programming languages like Python, JavaScript, and C++.

A statically typed, ahead-of-time compiled programming language with first-class hot-reloading for live applications.

A dynamically typed scripting language designed for seamless integration with Rust, featuring a lifetime checker and no garbage collector.

An embedded scripting language and evaluation engine for Rust, designed for safe and easy scripting integration.

An embeddable dynamic programming language for Rust, designed for scripting and runtime extensibility.

A lightweight, modular JavaScript engine written in Rust with a focus on embeddability and data-oriented design.

A cross-platform Rust library for retrieving detailed system information like CPU, memory, processes, disks, networks, and components.

A Jinja2/Django-inspired template engine for Rust, featuring filters, testers, and inheritance.

A compile-time HTML template engine for Rust that transforms markup into specialized Rust code for maximum performance and type safety.

A high-performance string library leveraging SIMD and SWAR to accelerate search, hashing, sorting, and edit distances across C, C++, Python, Rust, and more.

A blazing-fast command-line toolkit for querying, slicing, analyzing, transforming, and validating tabular data (CSV, Excel, JSONL, etc.).

A command-line tool for displaying stylized ANSI fonts in the terminal with colors, gradients, and alignment.

A command-line tool and library that generates regular expressions from user-provided test cases.

A language that compiles to ECMAScript regular expressions, designed for better readability and maintainability.

A polyglot document intelligence framework with a Rust core for extracting text, metadata, and structured data from 91+ file formats.

A line-oriented search tool that extends ripgrep to search inside PDFs, Office documents, archives, and many other file types.

A Rust regular expression library with guaranteed linear time matching using finite automata.

A Rust library for compact ordered sets and maps using finite state transducers, enabling fast searches and range queries.

A lightning-fast search engine API that brings AI-powered hybrid search to your sites and applications.

A sub-millisecond full-text search library and multi-tenancy server written in Rust, designed for high performance and real-time indexing.

A full-text search engine library written in Rust, inspired by Apache Lucene.

An open-source application that stabilizes video using gyroscope and accelerometer data from cameras or external devices.

A high-performance live media server in Rust supporting RTMP, RTSP, WebRTC, HLS, and HTTP-FLV.

A fast and safe AV1 video encoder designed as a performant alternative to the reference encoder.

An open-source virtualization technology that creates secure, lightweight microVMs for container and serverless workloads.

A standalone, fast, and secure WebAssembly runtime that is standards-compliant and supports WASI.

An open-source implementation of lightweight VMs that perform like containers but offer VM-level isolation and security.

A container runtime written in Rust that implements the OCI runtime specification, designed for performance and memory efficiency.

An efficient and lightweight WebAssembly interpreter designed for embedded and constrained systems.

A powerful, pragmatic, and extremely fast Rust web framework for building scalable and reliable web services.

An async web framework for Rust focused on usability, security, extensibility, and speed.

Ergonomic HTTP routing and request-handling library for Rust with a focus on modularity and type safety.

A full-stack, isomorphic Rust web framework for building fast, declarative user interfaces with fine-grained reactivity.

A Rust web framework for building client-side and server-side applications using The Elm Architecture.

A Rust front-end framework for creating fast and reliable web apps with an Elm-like architecture.

A high-performance, fully specification-compliant GraphQL server library implemented in 100% safe Rust.

A friendly and fast command-line HTTP client with an intuitive syntax, designed as a high-performance alternative to HTTPie.

An ergonomic, batteries-included HTTP client for Rust with async/blocking support, TLS, and proxies.

A flexible Rust web framework focused on stability, safety, security, and speed.

A protective and efficient, low-level HTTP library for Rust, supporting HTTP/1 and HTTP/2 with client and server APIs.

An extensible, high-performance web framework for Rust built on hyper, designed for concurrency and safety.

A type-safe, blazingly fast GraphQL server library for Rust with full spec compliance and framework integrations.

A simple and lightweight web framework for Rust with an Express.js-inspired API.

A full-featured, easy-to-use web framework for building high-performance applications in Rust.

A powerful and simple Rust web framework with full HTTP protocol support and built-in OpenAPI integration.

A composable web server framework for Rust built on hyper, designed for ease of use and high performance.

A batteries-included framework for building authorization in your application with a declarative policy language.

A Rust library for parsing HTML and querying elements using CSS selectors.

A Rust library for building Discord bots and applications with full API coverage and async support.

An open-source webhooks service that handles deliverability, retries, and security with a single API call.

A full-featured, elegant framework for building Telegram bots in Rust.

Auto-generates OpenAPI documentation for Rust REST APIs using simple procedural macros and a code-first approach.

A lightweight, fast, always-up HTTP reverse proxy built in Rust, configurable at runtime without reloading.

A straightforward static site generator written in Rust for building fast, reliable websites.

A fast static site generator in a single binary with everything built-in, including Sass, syntax highlighting, and image processing.

A WebSocket (RFC6455) library for Rust providing client and server implementations with message and frame-level APIs.

A lightweight, stream-based WebSocket implementation for Rust, providing a complete RFC6455 protocol implementation.

A command-line tool for interacting with WebSockets, offering netcat/curl/socat-like functionality with advanced proxying and bridging capabilities.