Lib.rs

tar

file reader and writer. This library does not currently handle compression, but it is abstract over all I/O readers and writers. Additionally, great lengths are taken to ensure that the entire…

generic-array

Generic types implementing functionality of arrays

encoding_rs

A Gecko-oriented implementation of the Encoding Standard

pkg-config

run the pkg-config system tool at build time in order to be used in Cargo build scripts

const_format

Compile-time string formatting

cmake

A build dependency for running cmake to build a native library

ctor

__attribute__((constructor)) for Rust

slotmap

data structure

mockall

A powerful mock object library for Rust

typed-builder

Compile-time type-checked builder derive

blake2b_simd

a pure Rust BLAKE2b implementation with dynamic SIMD

wat

Rust parser for the WebAssembly Text format, WAT

vcpkg

find native dependencies in a vcpkg tree at build time in order to be used in Cargo build scripts

scraper

HTML parsing and querying with CSS selectors

nom_locate

A special input type for nom to locate tokens

bitcode

bitwise binary serializer

cfg-if

A macro to ergonomically define an item depending on a large number of #[cfg] parameters. Structured like an if-else chain, the first matching branch is the item that gets emitted.

memoffset

offset_of functionality for Rust structs

scale-info

Info about SCALE encodable Rust types

string_cache

A string interning library for Rust, developed as part of the Servo project

enum-iterator

Tools to iterate over all values of a type (e.g. all variants of an enumeration)

quick-protobuf

A pure Rust protobuf (de)serializer. Quick.

relative-path

Portable, relative paths for Rust

path-slash

Conversion to/from a file path from/to slash path

pathdiff

diffing paths to obtain relative paths

const_panic

const panic with formatting

fluent-uri

A generic URI/IRI handling library compliant with RFC 3986/3987

tsify

generating TypeScript definitions from rust code

wasmprinter

Rust converter from the WebAssembly binary format to the text format

downcast-rs

Trait object downcasting support using only safe Rust. It supports type parameters, associated types, and type constraints.

diff

An LCS based slice and string diffing implementation

httptest

HTTP testing facilities including a mock server

capnp-rpc

Cap'n Proto remote procedure call protocol

futures-buffered

future concurrency primitives with emphasis on performance and low memory usage

capnpc

Cap'n Proto code generation

r2d2_sqlite

SQLite and SQLCipher support for the r2d2 connection pool

assert_matches

Asserts that a value matches a pattern

typed-index-collections

Typed index version of Rust slice and Vec containers

pythonize

Serde Serializer & Deserializer from Rust <--> Python, backed by PyO3

prettytable-rs

printing pretty formatted tables in terminal

Inflector

Adds String based inflections for Rust. Snake, kebab, camel, sentence, class, title and table cases as well as ordinalize, deordinalize, demodulize, foreign key, and pluralize/singularize…

typewit

type-witness-based abstractions, mostly for emulating polymorphism in const fns

rspack_resolver

ESM / CJS module resolution

os_display

Display strings in a safe platform-appropriate way

serde_tuple

De/serialize structs with named fields as array of values

memcache

memcached client for rust

flagset

Data types and a macro for generating enumeration-based bit flags

jmespath

query language for JSON

auto_impl

Automatically implement traits for common smart pointers and closures

serde_html_form

(De-)serialization support for the application/x-www-form-urlencoded format

oxiri

fast implementation of IRI validation and relative IRI resolution

pinned-init

facilitate safe pinned initialization

foreign-types

A framework for Rust wrappers over C APIs

prost-wkt

Helper crate for prost to allow JSON serialization and deserialization of Well Known Types

shell-quote

shell-quoting strings, e.g. for interpolating into a Bash script.

annatar

A command line tool for making memes. Full readme available at: https://github.com/archer884/annatar

tlua

Zero-cost high-level wrapper for Tarantool-LuaJIT

sugar_path

Sugar functions for manipulating paths

specr-transpile

Converts Specr lang code to Rust

gc

Tracing garbage collector plugin for Rust

cargo-call-stack

Static, whole program stack usage analyzer

getset

we're ready to go! A procedural macro for generating the most basic getters and setters on fields

bevy_reflect

Dynamically interact with rust types

walkdir

Recursively walk a directory

typescript-type-def

Generate TypeScript type definitions for Rust types

tiny-fn

Type erased closures on stack

globset

Cross platform single glob and glob set matching. Glob set matching is the process of matching one or more glob patterns against a single candidate path simultaneously, and returning all of the globs that matched.

field-offset

Safe pointer-to-member implementation

unimock

A versatile and developer-friendly trait mocking library

async-backtrace

Efficient, logical 'backtraces' of async tasks

json-event-parser

A JSON event parser and serializer

hirun

A concurrent framework for asynchronous programming based on event-driven, non-blocking I/O mechanism

parsoid

Wrapper around Parsoid HTML that provides convenient accessors for processing and manipulation

narrow

Apache Arrow

dlib

Helper macros for handling manually loading optional system libraries

ar

encoding/decoding Unix archive files

dumpster

A concurrent cycle-tracking garbage collector

cruet

Adds String based inflections for Rust. Snake, kebab, camel, sentence, class, title and table cases as well as ordinalize, deordinalize, demodulize, foreign key, and pluralize/singularize…

jsonbb

A binary representation of json value, optimized for parsing and querying

document-features

Extract documentation for the feature flags from comments in Cargo.toml

smart-default

Rust custom-derive macro for Default with more control on the fields

exacl

Manipulate file system access control lists (ACL) on macOS, Linux, and FreeBSD

typeset

A DSL for defining source code pretty printers

sealed_test

A procmacro attribute to run your test in an isolated environment

fieldx

Procedural macro for constructing structs with lazily initialized fields, builder pattern, and serde support with a focus on declarative syntax

thunderdome

Fast arena allocator with compact generational indices

deriving_via

DerivingVia

json-subscriber

Customizable layer and subscriber for tracing that emits logs in JSON

brup

updating the BRAM contents of NextPNR Lattice ECP5 FPGA configuration files

docsplay

A derive macro for implementing the display Trait via a doc comment and string interpolation. Fork of displaydoc

soa-rs

A Vec-like structure-of-arrays container

boilerplate

Minimal compile-time Rust template engine

kawa

Agnostic representation of HTTP/1.1 and HTTP/2.0 for parsing, generating and translating HTTP messages, with zero-copy, made for Sōzu

thiserror-ext

Useful extension utilities for thiserror

steel-core

Core compiler and VM implementation for steel

diesel_full_text_search

Adds support for PostgreSQL full text search to Diesel

validit

Validate data structures internal state

impl-tools

Helper macros: autoimpl

dagger-sdk

A dagger sdk for rust, written in rust

binstall-tar

TAR file reader and writer. This library does not currently handle compression, but it is abstract over all I/O readers and writers. Additionally, great lengths are taken to ensure that the entire…

stageleft

Type-safe staged programming for Rust

framels

command line tool to list frame sequence in friendly way

cicada

Bash-like Unix shell

envy

deserialize env vars into typesafe structs

tau-engine

A document tagging library

eetf

encoding/decoding Erlang External Term Format

toml-query

work with toml::Value objects more conveniently

subenum

A proc-macro to create subsets of enums, that can be converted to and from

expry

Execute an expression on an encoded (binary) value, yielding another binary value (either in decoded or encoded form). Supports custom functions. Supports parsing the expression and converting the expression to bytecode.

enum-assoc

Procedural macro to associate constants with enum variants

expr-lang

expr language in Rust

datadriven

Rewritable table-driven testing

prometheus-parser

parsing and validating Prometheus query expressions

string_cache_codegen

A codegen library for string-cache, developed as part of the Servo project

rubbl

Facade crate and CLI interface for the Rubbl astrophysics data analysis framework

menu

#[no_std] command line interface

rnx

web development scaffold, support salvo and axum

serde-querystring

A query string deserializer based on serde

monster-regex

A custom regex spec

xso

XML Streamed Objects: similar to serde, but XML-native

zcat

netcat-inspired utility for zenoh

oo-bindgen

DSL-based binding geneator for C, C++, Java, and C#

cast_trait_object

Cast between trait objects using only safe Rust

rzopfli

A lossless data compression tool using Zopfli

alpm-buildinfo

command line interface for the parsing and writing of BUILDINFO files

scalable_cuckoo_filter

A variant of Cuckoo Filter whose size automatically scales as necessary

omg-idl-gen

A command line tool reading OMG IDL and generating corresponding Rust data types

localsavefile

Save and load structs from a local file. A convenience wrapper around the savefile crate.

unreal-doc

generating documentation from Unreal C++ sources

one_err

OneErr to rule them all

gito

expand the ability of git

valq

macros for querying semi-structured data with the JavaScript-like syntax

xee

Xee CLI. Swiss Army knife for XML. XPath and XSLT

const_env

Configure const and static items by environment variables

serde-roxmltree

Convert roxmltree documents into Serde-compatible types

rivia

reduce code verbosity

ordered

A wrapper for adding arbitrary partial/total order to a type

oxttl

Parser and serializer for languages related to RDF Turtle (N-Triples, N-Quads, Turtle, TriG and N3)

nacos_rust_client

nacos rust client

web-route

Ergonomic web route construction, joining, and population for Rust web frameworks

deduplicating_array

A serde serialization strategy that uses PartialEq to reduce serialized size

oxc_parser_napi

A collection of JavaScript tools written in Rust

wegglix

weggli is a fast and robust semantic search tool for C and C++ codebases. It is designed to help security researchers identify interesting functionality in large codebases.

dockerfile-parser

parsing, validating, and modifying Dockerfiles

globcmp

assesses whether one glob pattern matches a file path more closely than another glob pattern does

ruplacer

Find and replace text in source files

jsongrep

A JSONPath-inspired query language for JSON documents

query_map

VectorMap is a generic wrapper around HashMap<String, Vec<String>> to handle different transformations like URL query strings

drop-with-owned-fields

Safe and sound owned access to a struct’s fields in Drop: no more unsafe usage of ManuallyDrop!

qstring

Query string parser

sikula

query language

debian-watch

parser for Debian watch files

jslt

Everyones favorite xslt but for json

portaldi

An ergonomic lightweight compile-time depencency injection library

relconf

Manage configuration depending on the current path

prebindgen

Separate FFI implementation and language-specific binding into different crates

funcmap

Derivable functorial mappings for Rust

scafalra

scafalra(sca) is a command-line interface tool for managing templates

sophus

geometry for robotics and computer vision

cfg_eval

#[cfg_eval] in stable Rust 🙃

rudi-dev

Rudi - an out-of-the-box dependency injection framework for Rust

dynamic-graphql

Dynamic GraphQL schema

splice

Span-safe refactoring kernel for Rust using SQLiteGraph

culpa

error-handling syntax in Rust

braces

Convert path lists into compact brace expansion syntax

sparesults

SPARQL query results formats parsers and serializers

handlebars_misc_helpers

A collection of helpers for handlebars (rust) to manage string, json, yaml, toml, path, file, http request

serdapt

Composable adapters for #[serde(with = ...)] attribute

nskeyedarchiver_converter

Convert NSKeyedArchiver encoded plists to human readable formats

cfg-elif

Formatter-friendly conditional compilation at item and expression positions

morphix

Observing and serializing mutations

stremio-serde-hex

Hexadecimal encoding/decoding with serde

jxcape

A command line tool for creating JSON values

typid

(Typ)ed Unique (Id)entifiers

explicit-error

Explicit concrete Error type for binary crates

enumeration

An extension to rust enum

matched_enums

A macro that provides the option to bin enum attribute to match-statements. This makes it easier to convert values into enums.

copyless

Ways to eliminate memcpy calls when using the standard library

sigma-enum

A macro to simulate sigma types with enums

new_zealand

working with non-zero integers

bounded-static

Defines the ToBoundedStatic and IntoBoundedStatic traits

elain

Set a type's minimum alignment with const generics

field_access

Dynamically access struct fields

cargo-index

Cargo subcommand to manage a registry index

make

just making files and directories

rfc822-like

encoding used in control files implemented for serde

skill-manager

Manage AI coding tool skills for Claude, OpenCode, and Cursor

serde-env

deserialize env into structs via serde

ratio-metadata

Ratio's metadata model

serde_trim

serde deserialize_with String trim.Supports multiple std::collections types

soapy

Structure-of-arrays derive macro

any-fn

Dynamically-typed functions to represent any functions in Rust

typesafe_repository

Abstract data persistence in a safe and unified way

cargo-groups

Run cargo commands on a groups of crates in a workspace

necessist-backends

serde-enum-str

Serialize and deserialize enum string

miniarg

A minimal argument parser, with support for no-std and no-alloc

bevy_derive

derive implementations for Bevy Engine

texp

small tool for render templates

flatpage

file system based markdown flat page

moku

creating hierarchical state machines (HSM)

flapigen

connecting libraries written in Rust with other languages

firebirust

Firebird client library

zenoh-plugin-rest

The zenoh REST plugin

route_match

A context-agnostic http routing utility

compose-idents

macro for generating new identifiers (names of variables, functions, traits, etc) by concatenating one or more arbitrary parts and applying other manipulations

pgde

A macro library for consuming PostgreSQL row data into structs

compare_fields

Field-by-field comparisons for structs and vecs

fx-callback

A subscription based callback to inform subscribers about relevant data events within structs

php-literal-parser

parser for php literals

roughage

AsyncPipeline, a deadlock-free replacement for buffered streams

mockall_double

Test double adapter for Mockall

dbg-pls

Syntax aware pretty-printing debugging

pretty-type-name

a shorter version of std::any::type_name

ninja-writer

ergonomic library for writing Ninja build files

rocksdb-rayon

rayon's ParallelIterator for rocksdb

ffi_11

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

hmr

Hot Module Reploading for Rust

soupa

macro allowing expressions to be eagerly evaluated before a scope

enquote

Quotes and unquotes strings

ini-rs

Read and write INI files with funcions. Also allows direct access to INI data

re_log_types

The basic building blocks of the Rerun data types and tables

minenv

use env files to store config, env vars override them, in 50 lines of code instead of 1,500

cargo-hilly

projects that helps migrate flat module files (e.g., "foo.rs") into the more idiomatic Rust module layout

rotbl

Read Only Table

str_inflector

Adds String based inflections for Rust. Snake, kebab, camel, sentence, class, title and table cases as well as ordinalize, deordinalize, demodulize, foreign key, and pluralize/singularize…

bevy_mod_config

A Bevy plugin for configuration management

concat-idents

Allows concatenating multiple identifiers and using them everywhere

fieldx_aux

Various types and tools useful for fieldx crates and, potentially, to users of fieldx

qx

Eazy to use log analyzer

s3-path

Describe paths inside an S3 bucket like working with std's Path and PathBuf

netron

Extract Axum request data within Yew server functions similar to how leptos_axum provides extraction helpers for Leptos

options

The package provides a data structure for managing named parameters

juspay_jsonlogic

A JsonLogic implementation in Rust

enum-ptr

Ergonomic tagged pointer

identify

Strongly-typed UUIDs, statically associated with other types

alloc_counter

Count allocations, reallocations, deallocations. Allow, deny, or forbid allocations on an expression or function basis.

rudi

out-of-the-box dependency injection framework for Rust

better-routes

A powerful Rust library designed for generating type-safe and maintainable Axum routers

lookupvec

Container with Vec-like properties that also offers O(1) lookup of items based on an id field

spongebob

convert text to spongebob case a.k.a tHe MoCkInG sPoNgEbOb MeMe

gtmpl-moyan

The Golang Templating Language for Rust

lua52-sys

Bindings for Lua 5.2

serac

A static, modular, and light-weight serialization framework

aws-dynamo-derive

Helper crate for aws-sdk-dynamodb

leucite

sandboxing and limiting command execution

rules_derive

fast derive macros using macro_rules

googleapis-tonic-google-cloud-talent-v4beta1

A Google APIs client library generated by tonic-build

html-query

jq, but for HTML

googleapis-tonic-google-cloud-talent-v4

A Google APIs client library generated by tonic-build

cfg-exif

Conditional compilation in expressions

myip-foo

Official Rust client for myip.foo - free IP lookup API with geolocation

function_overloading

that adds function overloading

rush-var

Expand shell-style variables like $FOO and ${BAR:-default} recursively

pass-fu

wrapper around the legendary pass - Foo Pass!

field-ref

Field reference (like a member pointer to non-static data field in C++) for Rust

weak-self

WeakSelf is simple way to have a Weak pointer to yourself

stream_stats

Display realtime statistics from stdin. gunzip -c foo.gz | stream_stats > foo

monomo

Explicit trait monomorphization

late-static

Initialize static variables at runtime

take_mut

Take a T from a &mut T temporarily

my_rust_helloworld

A test for newbee

smallgraph

A small graph based on smallvec

five8_foo

foo

oi-unwrap

unwrap without unwrap

s-string

s!() macro for quick String::from()

foo-cargo-filename-test

Test repo to hack a build script for 'cargo install foo' to build a library as a DLL file

globgroups

Expands groups like foo{a,b}

mockimbap

macro for mocking Rust functions