Lib.rs

rand

Random number generators and other randomness functionality

ahash

A non-cryptographic hash function using AES-NI for high performance

twox-hash

XXHash and XXH3 algorithms

strsim

Implementations of string similarity metrics. Includes Hamming, Levenshtein, OSA, Damerau-Levenshtein, Jaro, Jaro-Winkler, and Sørensen-Dice.

crc

support of various standards

fastrand

fast random number generator

crypto-bigint

Pure Rust implementation of a big integer library which has been designed from the ground-up for use in cryptographic applications. Provides constant-time, no_std-friendly implementations…

xxhash-rust

xxhash

rustfft

High-performance FFT library written in pure Rust

scroll

A suite of powerful, extensible, generic, endian-aware Read/Write traits for byte buffers

noise

Procedural noise generation library

ulid

a Universally Unique Lexicographically Sortable Identifier implementation

stacker

A stack growth library useful when implementing deeply recursive algorithms that may accidentally blow the stack

bytecount

count occurrences of a given byte, or the number of UTF-8 code points, in a byte slice, fast

dissimilar

Diff library with semantic cleanup, based on Google's diff-match-patch

rstar

An R*-tree spatial index

fnv

Fowler–Noll–Vo hash function

float_eq

Compare IEEE floating point primitives, structs and collections for equality

crc32c

Safe implementation for hardware accelerated CRC32C instructions with software fallback

bitpacking

Fast integer compression/decompression via SIMD bit-packing. Port of simdcomp to rust.

wildmatch

string matching with single- and multi-character wildcard operator

highway

Native Rust port of Google's HighwayHash, which makes use of SIMD instructions for a fast and strong hash function

md5

The package provides the MD5 hash function

realfft

Real-to-complex forward FFT and complex-to-real inverse FFT for Rust

kiddo

A high-performance, flexible, ergonomic k-d tree library. Ideal for geo- and astro- nearest-neighbour and k-nearest-neighbor queries

pathfinding

flow, and graph algorithms

ff

building and interfacing with finite fields

passwords

useful tools to generate multiple readable passwords, as well as analyze and score them

uint

Large fixed-size integer arithmetic

crc-any

To compute CRC values by providing the length of bits, expression, reflection, an initial value and a final xor value. It has many built-in CRC functions.

strength_reduce

Faster integer division and modulus operations

oorandom

A tiny, robust PRNG implementation

gcd

Calculate the greatest common divisor

streaming-iterator

Streaming iterators

rdrand

random number generator based on rdrand and rdseed instructions

rand_hc

HC128 random number generator

topological-sort

Performs topological sorting

sgp4

A pure Rust implementation of the SGP4 algorithm for satellite propagation

nucleo

plug and play high performance fuzzy matcher

murmur3

hash

easy-smt

Easily interact with an smt solver as a subprocess

buffer-redux

Drop-in replacements for buffered I/O in std::io with extra features

treediff

Find the difference between arbitrary data structures

edit-distance

Levenshtein edit distance between strings, a measure for similarity

ndarray-linalg

Linear algebra package for rust-ndarray using LAPACK

robust

adaptive floating-point predicates for computational geometry

seahash

A blazingly fast, portable hash function with proven statistical guarantees

medians

Median, Statistical Measures, Mathematics, Statistics

rustfst

constructing, combining, optimizing, and searching weighted finite-state transducers (FSTs)

sketches-ddsketch

A direct port of the Golang DDSketch implementation

argminmax

(argmin & argmax in 1 function) with SIMD for floats and integers

zipf

A fast generator of discrete, bounded Zipf-distributed random numbers

textdistance

Lots of algorithms to compare how similar two sequences are

differential-dataflow

An incremental data-parallel dataflow platform

resolvo

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

task-local-extensions

Task-local container for arbitrary data

simd-adler32

A SIMD-accelerated Adler-32 hash algorithm implementation

slice-group-by

Iterators over groups in slices and strs

daachorse

Double-Array Aho-Corasick

fastcdc

(content defined chunking) in pure Rust

memx

memory functions like libc memcmp(), memchr(), memmem(), memcpy(), memset()

earcutr

port of MapBox's earcut triangulation code to Rust language

linfa-linalg

Pure-Rust implementation of linear algebra routines for ndarray

reed-solomon-novelpoly

reed solomon code / encoder / decoder with complexity O(n lg(n))

glass_pumpkin

A cryptographically secure prime number generator based on rust's own num-bigint and num-integer

jubjub

elliptic curve group

metrohash

high quality, high performance hash algorithm

hexf-parse

Parses hexadecimal floats (see also hexf)

nanorand

A tiny, fast, zero-dep library for random number generation

merkle_hash

Finds the hashes of all files and directories in a directory tree

hime_redist

Redistributable runtime library for parsers generated with Hime (LR, RNGLR)

gix-negotiate

gitoxide project implementing negotiation algorithms

raft

language implementation of Raft algorithm

z3

High-level rust bindings for the Z3 SMT solver from Microsoft Research

genetic_algorithm

A genetic algorithm implementation

GSL

binding for the GSL (the GNU scientific library)

chalk-recursive

Recursive solver for the Chalk project

ndarray-rand

Constructors for randomized arrays. rand integration for ndarray.

adler

clean-room implementation of the Adler-32 checksum

varpro

A straightforward nonlinear least-squares fitting library which uses the Variable Projection algorithm

reed-solomon-simd

Reed-Solomon coding with O(n log n) complexity. Leverages SIMD instructions on x86(-64) and AArch64.

ph

data structures based on perfect hashing

fractional_index

fractional indexing

foldhash

A fast, non-cryptographic, minimally DoS-resistant hashing algorithm

k

kinematics

contour

Compute isorings and contour polygons (using marching squares algorithm)

muldiv

trait for numeric types to perform combined multiplication and division with overflow protection

fast_paths

Fast shortest path calculations on directed graphs made possible by pre-processing the graph using Contraction Hierarchies

crossterm_winapi

WinAPI wrapper that provides some basic simple abstractions around common WinAPI calls

arrow-ord

Ordering kernels for arrow arrays

kd-tree

k-dimensional tree

levenberg-marquardt

algorithm built on top of nalgebra

vek

Generic 2D-3D math swiss army knife for game engines, with SIMD support and focus on convenience

special

The package provides special functions

smawk

Functions for finding row-minima in a totally monotone matrix

levenshtein

algorithm

rust-stemmers

some popular snowball stemming algorithms

rand_regex

Generates random strings and byte strings matching a regex

quad-rand

Pseudo random implementation with core atomics

cdshealpix

HEALPix tesselation

transpose

transposing multi-dimensional data

rithm

Arbitrary precision arithmetic

keyword_extraction

Collection of algorithms for keyword extraction from text

annembed

dimension reduction à la Umap

tantivy-fst

tantivy-specific fork from the fst crate from Burntsushi. (Please use the fst crate instead.)

rand_mt

Reference Mersenne Twister random number generators

boyer-moore-magiclen

fast string search algorithm implemented in Rust

num_convert

Type converting library, conversions integers by overflow addition, supports generics types

tailcall

Safe, zero-cost tail recursion

timely

A low-latency data-parallel dataflow system in Rust

dive-deco

A dive decompression models library (Buehlmann ZH-L 16C)

chalk-engine

Core trait engine from Chalk project

metaheuristics-nature

A collection of nature-inspired metaheuristic algorithms

reactive_graph

A fine-grained reactive graph for building user interfaces

naive_opt

The optimized naive string-search algorithm

timsort

modified MergeSort used in Python and Java

radsort

Radix sort implementation for sorting by scalar keys (integers, floats, chars, bools)

blurhash

A pure Rust implementation of blurhash

ndarray-slice

Fast and robust slice-based algorithms (e.g., sorting, selection, search) for non-contiguous (sub)views into n-dimensional arrays

dypdl

Libarary for Dynamic Programming Description Language (DyPDL)

meos

Rust bindings for MEOS C API

ddo

generic and efficient framework for MDD-based optimization

quantiles

a collection of approximate quantile algorithms

cam-geom

Geometric models of cameras for photogrammetry

rs-wordle-solver

solving Wordle-style puzzles. It provides multiple guessing algorithms, as well as building blocks for implementing your own Wordle solving algorithms.

dec

A decimal arithmetic library providing high-level, safe bindings to libdecnumber

dbsp

Continuous streaming analytics engine

mergable

user-friendly and efficient CRDTs

ranges

generic alternative to core/std ranges, set-operations to work with them and a range set that can efficiently store them with the least amount of memory possible

pocket_prover

A fast, brute force, automatic theorem prover for first order logic

rand_xoshiro

Xoshiro, xoroshiro and splitmix64 random number generators

cardinality-estimator

estimating the cardinality of distinct elements in a stream or dataset

bm25

BM25 embedder, scorer, and search engine

rand_simple

random number generator that is independent from the other libraries and based on XOR shift

itermore

🤸‍♀️ More iterator adaptors

orx-v

Traits to unify all vectors!

iroh-blobs

blob and collection transfer support for iroh

fakeit

Fake data generator library with 130+ functions

gxhash

non-cryptographic algorithm

rustsat

aims to provide implementations of elements commonly used in the development on software in the area of satisfiability solving. The focus of the library is to provide as much ease of use without giving up on performance.

usearch

Smaller & Faster Single-File Vector Search Engine from Unum

probminhash

Minhash algorithms for weighted Jaccard index

mockd

Fake data generator library with 130+ functions

scru128

Sortable, Clock and Random number-based Unique identifier

kube_quantity

adding arithmetic operations to the Quantity type from the k8s-openapi crate

cobs

Consistent Overhead Byte Stuffing (COBS) algorithm. COBS is an algorithm for transforming a message into an encoding where a specific value (the "sentinel" value) is not used…

t1ha

T1AH (Fast Positive Hash) hash function

incremental

computations, based on Jane Street's incremental

accurate

(more or less) accurate floating point algorithms

integer-sqrt

integer square root algorithm for primitive rust types

russcip

Rust interface for SCIP

fast_polynomial

Faster polynomial evaluation using Estrin's Scheme to exploit instruction-level parallelism

murmurhash32

murmurhash32_2

version-ranges

Performance-optimized type for generic version ranges and operations on them

glissade

that provides various utilities for animations and transitions

primes

A package for calculating primes using the Sieve of Eratosthenes, and using that to check if a number is prime and calculating factors. Includes an iterator over all primes.

meta_tools

Collection of general purpose meta tools

qwt

Quad Wavelet Tree

cubecl-linalg

CubeCL Linear Algebra Library

byteyarn

hyper-compact strings

adskalman

Kalman filter and Rauch-Tung-Striebel smoothing implementation using nalgebra, no_std

bit-matrix

bit matrices and vectors

extendhash

Rust Hash Extender

halfbrown

Multi backend HashMap for higher performance on different key space sizes

petal-neighbors

Nearest neighbor search algorithms including a ball tree and a vantage point tree

RustQuant_math

quantitative finance

rectangle-pack

A general purpose, deterministic bin packer designed to conform to any two or three dimensional use case

pacmap

Pairwise Controlled Manifold Approximation (PaCMAP) for dimensionality reduction

interp

Matlab's interp1 function

rust-spice

WOW! The complete NASA/NAIF Spice toolkit is actually usable on Rust

cubecl

Multi-platform high-performance compute language extension for Rust

rurel

Flexible, reusable reinforcement learning (Q learning) implementation

adler32

Minimal Adler32 implementation for Rust

triple_accel

Rust edit distance routines accelerated using SIMD. Supports fast Hamming, Levenshtein, restricted Damerau-Levenshtein, etc. distance calculations and string search.

gcra

A basic implementation of GCRA algorithm for rate limiting

clingo

Rust idiomatic bindings to the clingo library

basic_dsp_matrix

Digital signal processing based on real or complex vectors in time or frequency domain

sfcgal

High-level bindings to SFCGAL and conversion from/to other geometry libraries

fuzzy-muff

Fuzzy Matching Library

relp

Rust Exact Linear Programming

macro-machines

State machine macros with logging and graphviz DOT file generation

turborand

Fast random number generators

highs

Safe rust bindings for the HiGHS linear programming solver. See http://highs.dev.

adler2

clean-room implementation of the Adler-32 checksum

ids_service

that allows to generate unique Ids

random_word

Efficient functions for generating random words in many languages

nozomi

Equivalent of the Linux shred command but in rust and library. Allows you to securely erase data from a hard drive.

lazy-bytes-cast

Lazy casts from & to byte arrays

optirustic

A multi-objective optimisation framework for Rust

cap-rand

Capability-based random number generators

vrp-core

A core algorithms to solve a Vehicle Routing Problem

hime_sdk

Development kit for the generation of LR and RNGLR parsers programmatically or in command line. Full API for the manipulation of context-free grammars.

union-find

Struct and methods for union-find operation

tinymt

64/32 - a lightweight variant of Mersenne Twister PRNG

rustics

statistic library for performance analysis

scnr

Scanner/Lexer with regex patterns and multiple modes

dilate

A compact, high performance integer dilation library for Rust

polylog

polylogarithms

diff-match-patch-rs

A high-performance port of Myer's diff algorithm to perform the operations required for synchronizing plain text

rustfst-ffi

constructing, combining, optimizing, and searching weighted finite-state transducers (FSTs). Rustfst-ffi provides C interfaces of the Rust library

rsc_osrm

rust wrapper for osrm, folk from TehGoat/rs_osrm

av-metrics

A collection of algorithms for measuring audio/video metrics

smolprng

A Small and Extensible PRNG written in Rust

satkit

Satellite Toolkit

alphanumeric-sort

can help you sort order for files and folders whose names contain numerals

wyrand

A fast & portable non-cryptographic pseudorandom number generator and hashing algorithm

fletcher

A dependency free implementation of the Fletcher's checksum algorithm

gat-lending-iterator

iterators who's items can [mutably] reference the iterator

rust-analyzer-salsa

A generic framework for on-demand, incrementalized computation (experimental)

wyhash

fast portable non-cryptographic hashing algorithm and random number generator

cryptocol

cryptographic library that includes big number arithmatic operation, hash algorithms, symmetric-key cryptographic encryption/decryption algorithms, asymmetric-key (public-key) cryptographic…

color_space

converting between color spaces and comparing colors

float_next_after

A trait for native rust f64/f32 nextafter

hierarchical_hash_wheel_timer

A low-level timer implementantion using a hierarchical four-level hash wheel with overflow

kdtree

K-dimensional tree in Rust for fast geospatial indexing and nearest neighbors lookup

starlight

experimental HDL and optimizer for DAGs of lookup tables

mpchash

Multi-probe consistent hashing algorithm implementation

lt-fm-index

Fm-index using k-mer lookup table for exact pattern matching

ra_ap_salsa

A generic framework for on-demand, incrementalized computation (experimental)

extsort

External sorting (i.e. on disk sorting) capability on arbitrarily sized iterator

merkle-cbt

generating efficient Merkle tree and combined Merkle proof based on complete binary tree

easyfft

providing an easy FFT API for arrays and slices

kmeans

Small and fast library for k-means clustering calculations

hmac-sha1

wrapper around the RustCrypto hmac and sha1 crates for simple HMAC-SHA1 generation

xxhrs

Safe XXHash and XXH3 bindings

mesh_to_sdf

Mesh to signed distance field (SDF) converter

contour-isobands

Compute isobands and contour polygons (using marching squares algorithm)

raftify

Experimental High level Raft framework

trie_rcv

Ranked Choice Voting implementation using Tries in Rust

h3o-zip

A compression scheme tailored for H3 cell indexes

rex-sm

Hierarchical state machine

ran

fast random numbers generation

general-sam

A general suffix automaton implementation in Rust

gix-revwalk

providing utilities for walking the revision graph

arrow-string

String kernels for arrow arrays

atomic-traits

The traits for generic atomic operations

dotlr

An LR(1) parser generator and visualizer created for educational purposes

hyperloglogplus

HyperLogLog implementations

opensimplex2

Port of OpenSimplex2

interval_adapter

Interval adapter for both open/closed implementations of intervals ( ranges )

graaf

Work with directed graphs

startin

A Delaunay triangulator for terrains

tiny_sort

Binary-size optimized stable and unstable sorts

graph-algorithms-rs

A collection of graph algorithms

dogear

merging bookmark trees

pasture-algorithms

Point cloud algorithms for pasture

cyclic-poly-23

A rolling, decomposable hash algorithm

swift_vec

A convenient and comfortable vector maths crate that supports 2D, 3D, and 4D matrices and vectors - along with additional scalar math

rdst

A flexible parallel unstable radix sort that supports sorting by any arbitrarily defined sequence of bytes

autour_core

AUTOmata Utilities and Representation (AUTOUR) is a small toolbox to experiment with various kinds of automata and draw them

treerder

Trie ordering for type implementing Orderable

uniset

A hierarchical, growable bit set with support for in-place atomic operations

sequence-generator-rust

Customizable 64-bit unique distributed IDs sequence generator based on Twitter's ID (snowflake). Build in Rust

uutils_term_grid

formatting strings into a grid layout. Fork of term_grid.

rand_chacha

ChaCha random number generator

line-span

Find line ranges and jump between next and previous lines

sigmah

Create and scan binary signature in Rust efficiently

probability

The package provides a probability-theory toolbox

iban

IBAN parsing library

simsearch

lightweight fuzzy search engine that works in memory, searching for similar strings (a pun here)

times

Timing Benchmark, Repeated Runs, with Statistics

i_triangle

Polygon Triangulation Library: Efficient Delaunay Triangulation for Complex Shapes

wavefc

A home-grown implementation of the Wave Function Collapse algorithm

many-unzip

multiunzip from itertools but with support for larger than 12-tuples

tau-engine

A document tagging library

dmsort

Fast adaptive sorting for when most of your data is already in order. dmsort can be 2-5 times faster than Rust's default sort when more than 80% of the elements are already in order

stringmetrics

approximate string matching

jaime

j.a.i.m.e. is an ergonomic all purpose gradient descent engine

hnsw_rs

Ann based on Hierarchical Navigable Small World Graphs from Yu.A. Malkov and D.A Yashunin

simple_hll

HyperLogLog implementation in rust

rgeometry

High-Level Computational Geometry

zeros

timberio/file-source

A high-performance observability data pipeline

subset_sum

Solves subset sum problem and returns a set of decomposed integers. It also can match corresponding numbers from two vectors and be used for Account reconciliation.

num-order

Numerically consistent Eq, Ord and Hash implementations for various num types (u32, f64, num_bigint::BigInt, etc.)

kewb

manipulating and solving a 3x3 Rubik's cube with Kociemba's two phase algorithm

axgeom

that provides ability to extract 1d ranges out of 2d objects

crunch

A packer for cramming lots of rectangles into a larger one, designed primarily with sprite packing in mind

conhash

Consistent Hashing library in Rust

raftbare

Minimal but feature-complete, I/O-free implementation of Raft distributed consensus algorithm

geometry-predicates

port of robust geometric predicates

counting_sort

Counting sort implementation for Iterators

vecmath

type agnostic library for vector math designed for reexporting

natord

Natural ordering for Rust

bit_gossip

Pathfinding library for calculating all node pairs' shortest paths in an unweighted undirected graph

ckey

consistent hash key library

pathfinding_astar

A-Star pathfinding algorithm that can process absract and grid-like paths

to_shmem

Trait to write to a contiguous chunk of shared memory

s2-tilejson

Backwards compatible JSON format for describing s2 map tilesets

grid_pathfinding

Pathfinding using JPS and connected components on a grid

drain_filter_polyfill

current nightly implementation of Vec::drain_filter, copypasted out for use on stable

seastar

Dependency-free implementation of the A* pathfinding algorithm for uniform-cost, 2D grids in cardinal directions

tinyrand

Lightweight RNG specification and several ultrafast implementations in Rust

importunate

Methods for returning random elements from an iterator

pumpkin-solver

The Pumpkin combinatorial optimisation solver library

algorithmica

Rust Algorithms

fast-tlsh

generate / parse / compare TLSH locality sensitive hashes

four-bar

Four🍀bar library provides simulation and synthesis function for four-bar linkages

volute

Boolean functions implementation, represented as lookup tables (LUT) or sum-of-products (SOP)

peek-again

A performant iterator providing double peek functionality

pyin

pYIN pitch detection algorithm written in Rust

graph_process_manager_loggers

Generic loggers for graph_process_manager_core

belnapian

Belnap's 4-valued logic basic building blocks in Rust

hypertwobits

cardinality estimation algorithm

multistochgrad

Stochastic Gradient, Multithreaded

randevu

The official Rust implementation of the RANDEVU algorithm

nlopt

Wrapper for the nlopt library

bit_manipulation

lightweight Rust crate for seamless management and validation of up to 128 option states. Empower your applications with efficient, flexible, and intuitive option handling, ensuring…

rand_aes

AES based pseudo-random number generator

easer

Tiny library imlementing Robert Penner's easing functions

count-digits

A no-std trait to determine the lengths of integers in various number bases

relp-num

Number types for the relp crate

sobol_burley

A seedable Owen-scrambled Sobol sequence

recursive

Easy recursion without stack overflows

cassowary

linear constraint solving algorithm. The Cassowary algorithm is designed for naturally laying out user interfaces using linear constraints, like 'this button must line up with this text box'

tolerance

Math representation of the physically needed permissible deviation of measures

kendalls

Kendall's tau rank correlation

programinduction

program induction and learning representations

fuse-rust

Fuse is a super lightweight library which provides a simple way to do fuzzy searching. Fuse-Rust is a port of Fuse-Swift, written purely in rust

rand_jitter

Random number generator based on timing jitter

pg_task

Resumable state machine based Postgres tasks

permutator

Get a lexicographic cartesian product and lexicographic permutation at any specific index from data. Generate complete lexicographic cartesian product from single or multiple set of data…

flo_binding

Declarative binding library for Rust

explicit-endian

Transparent traits to explicitely declare in-memory endianness for a virable or struct record

ragged-buffer

Efficient RaggedBuffer datatype that implements 3D arrays with variable-length 2nd dimension

oxidd-reorder

Reordering algorithms for OxiDD

openraft-sledstore

A sled based implementation of the openraft::RaftStorage trait

is-tree

Everything is a tree

dredd-rs

rules engine for Rust, adapted from the Dredd implementation for Android

english-to-cron

converts natural language into cron expressions

dynalgo

A tiny library designed to produce animated SVG images that can illustrate graph algorithms in action

qptrie

A QP-Trie implementation for Rust

tifloats

Speedy, accurate emulation of TI-Floats

random-pick

Pick an element from a slice randomly by given weights

convolve2d

Easy and extensible pure rust image convolutions

mt19937

A translation of the MT19937 Mersenne Twister rng algorithm to Rust

density-rs

Superfast compression library

solaris-rs

predict the position of the Sun

rufl

A powerful util function library for rust

partial_sort

version of std::partial_sort

rake

Rapid Automatic Keyword Extraction (RAKE) algorithm

hyperloglog

in Rust

geo-clipper

Boolean operations on polygons

truck-polymesh

defines polygon data structure and some algorithms handling mesh, including meshing the shapes

controlled_astar

that provides an enhanced A* pathfinding algorithm with controllable node directions and block statuses, ideal for complex pathfinding scenarios

kalmanfilt

Kalman and other filters from Kalman-and-Bayesian-Filters-in-Python

xentrace-parser

A XenTrace files parser with a study purpose

zorder

Fast Z-order curve conversions

probabilistic_bisector

bisection for one-dimensional functions in the presence of noise

sapling-dag

DAG used for source control

spec_math

implementations of special mathematical functions. Includes re-implementation of the CEPHES math library for gamma functions, error functions, elliptic integrals, sine and cosine integrals…

augurs-dtw

Dynamic Time Warping (DTW) algorithm for Rust

tf-binding-rs

Fast transcription factor binding site prediction and FASTA manipulation in Rust

radiate

genetic algorithms and artificial evolution

rust_intervals

Intervals arithmetic with any combination of open, closed or infinite bounds, along with operations like intersection, convex hull, union, difference,

multimarkov

generic tool for training and using multi-order Markov chains for procedural generation applications such as generating randomized but authentic-sounding names for characters and locations

weighted_rand

A weighted random sampling crate using Walker's Alias Method