Lib.rs

trybuild

Test harness for ui tests of compiler diagnostics

sqlparser

Extensible SQL Lexer and Parser with support for ANSI SQL:2011

proptest

Hypothesis-like property-based testing and shrinking

syntect

high quality syntax highlighting and code intelligence using Sublime Text's grammars

crossbeam

Tools for concurrent programming

rust-ini

An Ini configuration file parsing library in Rust

group

Elliptic curve group traits and utilities

unicode-ident

Determine whether characters have the XID_Start or XID_Continue properties according to Unicode Standard Annex #31

log4rs

A highly configurable multi-output logging implementation for the log facade

tikv-jemalloc-sys

Rust FFI bindings to jemalloc

gdbstub

GDB Remote Serial Protocol in Rust

fastrace

A high-performance timeline tracing library for Rust

pdfium-render

A high-level idiomatic Rust wrapper around Pdfium, the C++ PDF library used by the Google Chromium project

regalloc2

Backtracking register allocator inspired from IonMonkey

sgp4

A pure Rust implementation of the SGP4 algorithm for satellite propagation

puffin

instrumentation profiler for games

rust-htslib

HTSlib bindings and a high level Rust API for reading and writing BAM files

serde_arrow

Convert sequences of Rust objects to Arrow arrays and back again

differential-dataflow

An incremental data-parallel dataflow platform

plotlars

designed to facilitate the integration between the Polars data analysis library and visualization libraries

pathrs

C-friendly API to make path resolution safer on Linux

cargo-lock

Self-contained Cargo.lock parser with optional dependency graph analysis

aegis

authenticated ciphers (AEGIS-128, AEGIS-256, AEGIS-128X, AEGIS-256X)

resolvo

Fast package resolver written in Rust (CDCL based SAT solving)

pco

Good compression for numerical sequences

pwd-grp

Access Unix passwords and groups

kbs2

A secret manager backed by age

vob

Vector of Bits with Vec-like API and usize backing storage

zawk

An efficient Awk-like language implementation by Rust with stdlib

orderbook-rs

high-performance, lock-free price level implementation for limit order books in Rust. This library provides the building blocks for creating efficient trading systems with support for…

nova-snark

High-speed recursive arguments from folding schemes

simpleaf

framework to make using alevin-fry even simpler

vers-vecs

A collection of succinct data structures supported by fast implementations of rank and select queries

ffzap

⚡ A multithreaded CLI for digital media processing using ffmpeg. If ffmpeg can do it, ffzap can do it - as many files in parallel as your system can handle.

asm-lsp

Language Server for x86/x86_64, ARM, RISCV, and z80 Assembly Code

xdl-gui

GUI application for XDL with integrated CLI and plotting

tendril

Compact buffer/string type for zero-copy parsing

jubjub-plus

Jubjub elliptic curve group

ensync

A flexible ENcrypted file SYNChroniser suitable for uses where the central location is not fully trusted

zepter

Analyze, Fix and Format features in your Rust workspace

autobib

An automatic bibliography generation tool

rokit

Next-generation toolchain manager for Roblox projects

jacquard-lexicon

Lexicon schema parsing and code generation for Jacquard

alevin-fry

A suite of tools for the rapid, accurate and memory-frugal processing single-cell and single-nucleus sequencing data

crymap

secure IMAP server with encrypted data at rest

alog

Anonymize 'Combined Log Format' data

machine-prime

ne plus ultra primality testing for machine-sized integers

tor-basic-utils

General helpers used by Tor

tlauc

Rewrites TLA⁺ specs to use Unicode symbols instead of ASCII, and vice-versa

cargo-pgo

Cargo subcommand for optimizing Rust binaries with PGO and BOLT

mad-useful

A multi-tool utility for file operations and text processing

kreuzberg-pdfium-render

⚠️ TEMPORARY FORK - Use pdfium-render instead. A high-level idiomatic Rust wrapper around Pdfium, the C++ PDF library used by the Google Chromium project.

qbt-clean

Automated rules-based cleaning of qBittorrent torrents

syndicate-server

Dataspace server

smmalloc

smalloc is a very simple but performant allocator

packedvec

Store vectors of integers efficiently

mask-hx

Generic Haxe version manager

perfetto-recorder

A low overhead way to record perfetto traces from Rust code

nfs3_server

NFSv3 Server implementation

neorusticus

A Prolog implementation in Rust with enhanced error handling

zuqe

Zuqe JS Engine - A lightweight JS engine implemented in Rust, designed for embedded systems and general‑purpose use

mcslock

Mellor-Crummey and Scott contention-free lock for mutual exclusion, referred to as MCS lock

basalt-tui

Basalt TUI application for Obsidian notes

bend-lang

A high-level, massively parallel programming language

binary-ensemble

A CLI tool for working with and compressing ensembles of districting plans

fast_rsync

An optimized implementation of librsync in pure Rust

legion_prof

Legion Prof: a profiler for Legion

aisle

Metadata-driven Parquet pruning for Rust: Skip irrelevant data before reading

barbell

Extremely fast and accurate Nanopore demultiplexing

armv4t_emu

An emulator for the ARMv4t instruction set

serde_bibtex

A BibTex (de)serialization file format

loro-rle

A internal library of loro for storing and manipulating run-length encoded data. Do not use it directly.

sas7bdat

+ CLI for decoding SAS7BDAT datasets and streaming them to modern formats

dioxus-lib

Build fullstack web, desktop, and mobile apps with a single codebase

spatialtree

A fast and flexible generic spatial tree collection (Octree, Quadtree, etc)

egui-selectable-table

egui to create tables with draggable cell and row selection

fastLoess

High-level, parallel LOESS (Locally Estimated Scatterplot Smoothing) implementation in Rust

midi-reader-writer

Facilitate reading and writing midi files

extarray

Space-Efficient Extensible Arrays

regex-bites

A lightweight regex engine that optimizes for binary size and compilation time

uring-file

Async file I/O for Linux using io_uring

fast-ssim2

Fast SSIMULACRA2 image quality metric with SIMD acceleration

zip_static_handler

Static file handler from zip archive

alloc-track

Track memory allocations by backtrace or originating thread

cjson-bindings

Safe Rust bindings for the cJSON library - a lightweight JSON parser in C with support for JSON Pointer (RFC6901), JSON Patch (RFC6902), and JSON Merge Patch (RFC7386)

tai-time

Nanosecond-precision monotonic clock timestamps based on the TAI time standard

fidget

Infrastructure for complex closed-form implicit surfaces

fortress-rollback

Fortress Rollback (a fork of GGRS) is a fortified, verified P2P rollback networking library for Rust

pracstro

astronomy library

phylo

An extensible Phylogenetics library written in rust

fluxio

thermal_hydraulics_rs

A Thermal Hydraulics Library with some useful traits,enums and functions for heat transfer and fluid mechanics

beet_net

Cross-platform networking utilities

cait_sith_keplr

Threshold ECDSA via Triples

ppl

A structured parallel programming library for Rust

service_utils

service integration testsing

librashader-capi

RetroArch shaders for all

suika

web stack for building web applications

sit-rs

Rust-native extraction for StuffIt Expander archive files

tzarrays

Optimal resizable Arrays

rabitq-rs

Advanced vector search: RaBitQ quantization with IVF and MSTG (Multi-Scale Tree Graph) index

topological-coherence

Topological constraints for coherent inference - Tonnetz geometry primitives for attention mechanisms

anystack

Flexible and comprehensive error handling

jsonwebtokens

A Json Web Token implementation for Rust

single_rust

Single-cell analysis in Rust

hx711_spi

A platform agnostic driver to interface with the HX711 using SPI

sosecrets-rs

Secret wrapper type that reveals the secret at most MEC: typenum::Unsigned times with compile time guarantees

posix-acl

interact with POSIX filesystem ACLs

byondapi

Idiomatic Rust bindings for BYONDAPI

gtfsort

An optimized chr/pos/feature GTF/GFF sorter using a lexicographic-based index ordering algorithm written in Rust

bintensors

high-performance binary tensor serialization format designed to be faster eliminating use of JSON serialization metadata

pdk-proxy-wasm-stub

Due to a linker error in Windows (https://github.com/rust-lang/rust/issues/86125) that fails when importing a crate that has external symbols, even when they are not being used, we need a proxy-wasm-stub for non…

functora-tagged

Lightweight, macro-free newtypes with refinement and derived traits

optivorbis

A lossless, format-preserving, two-pass Vorbis optimization and repair library

rkvs

A high-performance, namespace-based key-value storage system with async operations and batch processing

sanitise-file-name

An unusually flexible and efficient file name sanitiser

sen6x

no-std driver for the SEN6X sensor modules

outfit

Orbit determination toolkit in Rust. Provides astrometric parsing, observer management, and initial orbit determination (Gauss method) with JPL ephemeris support.

webgl2

shader compiler, emulator, and debugger

csvmd

Convert from CSV to a Markdown table

oxitoken

Fastest and most secure JWT encoding/validation library for Rust. Fully supports custom header/claims structs, an extendable validation pipeline, and is crypto-backend agnostic (built-in…

tinyrand

Lightweight RNG specification and several ultrafast implementations in Rust

vec-belt

Multi-threaded bulk-append, single-threaded consume Vec<T>

skulpin

easy option for drawing hardware-accelerated 2D by combining Vulkan and Skia

fnorder

Totally non-randomly generated messages from the Illuminati

arx-kw

ARX-KW-8-2-4 Key Wrap constructions

osrm_interface

Interface into osrm-backend, supporting native C++ binding and a wrapper around the HTTP request API

serverless-cost-calculator

Estimate the cost of TiDB Serverless for your existing MySQL-compatible databases

fuzzy_rocks

A persistent datastore backed by RocksDB with fuzzy key lookup using an arbitrary distance function accelerated by the SymSpell algorithm

readability-rust

port of Mozilla's Readability library for extracting article content from web pages

debate

A principled, type-driven CLI parser. Debate is a more sensible way to handle (command-line) arguments.

ffi_11

One-to-one FFI types for C++/Rust interop

thag_profiler

A lightweight, cross-platform Rust code profiling toolkit with zero overhead when disabled

fastmod

Fast, partial replacement for codemod (find/replace tool for programmers)

llkv-sql-pong-demo

Watch a terminal play pong against itself using the LLKV SQL engine in a game loop. Mainly for perf evaluation.

galvanic-assert

comprehensive set of matcher-based assertions and expectations for easier testing. Supports checking properties of numbers, objects, enum variants, collections, panics, and more. Stuctural…

unf

UNixize Filename -- replace annoying anti-unix characters in filenames

sta-rs

Distributed Secret-Sharing for Threshold Aggregation Reporting

encoding-next

Character encoding support for Rust

hyperloglog-rs

HyperLogLog trying to be parsimonious with memory

linked-markov

A minimal, thread-safe Markov chain implementation using reference-counted steps and weighted transitions

conda_curation

Reduce conda repodata to enforce policy and speed up solves. Alpha software.

stackmap

A fast stack-only hashmap for small high-performance scenarios

bevy_ui_widgets

Unstyled common widgets for Bevy Engine

intel/cloud-hypervisor

Open source Virtual Machine Monitor (VMM) that runs on top of KVM & MSHV

rules_derive

fast derive macros using macro_rules

letta

A robust Rust client for the Letta REST API

blazing_agi

FastAGI server focusing on ergonomics and correctness

readabilityrs

port of Mozilla's Readability library for extracting article content from web pages

deep_causality_rand

Random number utils for for deep_causality crate

credx

Anonymous Credentials 2.0 implemention

ncp-matcher

plug and play high performance fuzzy matcher

prdoc

cli

unsend

A thread unsafe runtime for thread unsafe people

rust-guile

Scheme runtime in your Rust program

beet_examples

Bits and pieces for substantial beet examples

bitman

An easy to use bit manipulation library for Rust

orcast

OHLCV-driven options ticker screener (Rust). Fetch daily bars; rank tickers per strategy category.

stereokit

Higher-Level wrapper around stereokit-sys bindings for StereoKitC library for XR

ubersession

mechanism for cross-domain WWW session establishment - command line program

lz-fear

A fast pure-rust no-unsafe implementation of LZ4 compression and decompression

coe

full implementation of the CoEv2 protocol by Technische Alternative

fn-dsa

signature scheme

mozilla/logins

Firefox Application Services

banzai

A pure Rust bzip2 encoder

piston_mix_economy

A research project to mix-regulate economy in MMO worlds

docker-source-checksum

Deterministic source-based docker image checksum

vlog_db

High-performance embedded key-value database with LSM-tree architecture, ACID transactions, and value-log separation

num-runtime-fmt

Format numbers according to a format spec determined at runtime

oasiscap

Types for the OASIS Common Alerting Protocol (CAP)

columnation

Unsafe columnar containers for native Rust types

sqlparser-lance

A fork of sqlparser-rs project

scalpel

Packet dissection and sculpting in Rust

lens

Unified Lens query language

libcvss

CVSS specification

jindex

Enumerate the paths through a JSON document

bevy_sparse_tilemap

A Tilemap crate for the Bevy game engine with a focus on large map sizes and ECS sparse maps

memory_pages

memory_pages provides a cross-platform memory management API which allows for acquiring memory pages from the kernel and setting permissions on them

unroll

An attribute-like procedural macro for unrolling for loops

pagong

A static site generator for slow connections

barter-instrument

Core Barter Exchange, Instrument and Asset data structures and associated utilities

asuran

Deduplicating, encrypting, fast, and tamper evident archive format

lex_sleuther

Sleuth out script languages by lexing

mcsdf-font-tech-demo

Multi-channel signed distance fields font tech demo

see

A high-performance, asynchronous runtime-agnostic alternative to tokio::sync::watch

vdf

Verifiable Delay Functions (VDFs) in Rust

warp-rate-limit

Rate-limiting middleware for the Warp web framework

bbolt-rs

port of the Bolt database

csparse21

Sparse Matrix Solver

swap-queue

A lock-free thread-owned queue whereby tasks are taken by stealers in entirety via buffer swapping

cribtools

CLI for reading genome track files

xsave

x86 XSave semantics

capy-graph

A framework for constructing arithmetic circuits on-the-fly

entwine

Generic slice-like interface for operating on multiple slices at the same time

variegated-board-cfg

Store pin and other HAL configurations for your embedded project in a TOML file

upodesh

generating Bengali word suggestions based on a given input string

little-loadshedder

Latency-based load-shedding hyper/tower middleware

llrt_utils

LLRT utilities

lifthrasiir/angolmois

BMS player

serbzip

A quasi-lossless Balkanoidal meta-lingual compressor

idx-rs

A fast and efficient library for working with IDX-formatted RuneScape caches

max7301

Driver for the MAX7301 serial I/O expander

rubbl_casatables

Interfacing to the CASA table format within the Rubbl framework

log4rsx

A highly configurable multi-output logging implementation for the log facade

noel

A GTF/GFF per gene non-overlapping exon length calculator

rz

rt is a command line utility to add license text to your source code files so you can focus on production

fj-operations

Early-stage, next-generation, code-first CAD application. Because the world needs another CAD program.

bose-dfu

Firmware updater for various Bose devices

serde_dbus

Serde Implementation for DBus

core-to-core-latency-plus

This program is used to calculate the communication latency between CPU cores

gds21

Integrated Circuit Layout Parser & Writer

cuda

CUDA bindings

textr

TeX-inspired plug-n-play interface for converting JSON documents into PDFs

bananapeel

A darn-slippery obfuscator algorithm!

nilsimsa

locality-sensitive hashing algorithm

leptos_image

Static Image Optimizer for Leptos

roracache

FUSE filesystem that bolts aggressive caching and readahead onto another filesystem

topfew

CLI to find high frequency occurrences in structured text files

pemmican

Web Framework

tantivy-uffd

Query a remote tantivy index with HTTP range requests

ruleset

Monotonic chart parsing

async-nng

Async wrappers for working with nng-rs types and operations

stampiotic

A flyweight tool for checking stampfile freshness

vec-with-gaps

A data structure that behaves like a vec of vecs, but where the subvecs are kept in one contiguous section of memory, which improves cache performance for some workloads

network_helpers_sv2

Networking utils for SV2 roles

genomic_interval_pipeline

A pipeline for creating HDF5 databases from genomic intervals

base64-bytes

Binary blobs with intelligent serialization

voronoiify-image

Divide a PNG image into random nearest-neighbour regions and give each regio the average color of its pixels

noosphere-gateway

A geist on the network that enables user spheres to discover each other

epoxy_frp

The Reactive Glue for Frontend Applications

geocodio_lib_rust

A client library to interface with the Geocodio API

fux_kdtree

K-dimensional tree implemented in Rust for fast NN querying

hashseq

A BFT Sequence CRDT suitable for unpermissioned networks with unbounded number of collaborators

acpica-sys

Bindings to the ACPI Component Architecture

caser

Change text between PascalCase, camelCase, and snake_case

rkdb

KDB-Rust embedding and IPC

crib

reading genome track files

keyword-tools

Rust tools for keyword extraction and similarity search

bevis

Fiat-Shamir without the Hassle

drax

abstraction layer over a protocol buffer, bringing dtos to regular types

chaindexing

Index any EVM chain and query in SQL

flash-kv

k/v store API inspired by bitcask

nip

A git remote helper for IPFS that puts your files Nowhere In Particular

play-files

parsing Polyend Play projects into Rust structs

nype

Newtype helper macros for Rust