Lib.rs

rand

Random number generators and other randomness functionality

twox-hash

XXHash and XXH3 algorithms

ahash

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

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

xxhash-rust

xxhash

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…

rustfft

High-performance FFT library written in pure Rust

noise

Procedural noise generation library

scroll

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

stacker

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

ulid

a Universally Unique Lexicographically Sortable Identifier implementation

dissimilar

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

fnv

Fowler–Noll–Vo hash function

rstar

An R*-tree spatial index

bytecount

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

float_eq

Compare IEEE floating point primitives, structs and collections for equality

realfft

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

bitpacking

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

crc32c

Safe implementation for hardware accelerated CRC32C instructions with software fallback

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

kiddo

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

md5

The package provides the MD5 hash function

pathfinding

flow, and graph algorithms

uint

Large fixed-size integer arithmetic

ff

building and interfacing with finite fields

passwords

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

rand_hc

HC128 random number generator

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.

oorandom

A tiny, robust PRNG implementation

jubjub

elliptic curve group

slice-group-by

Iterators over groups in slices and strs

gcd

Calculate the greatest common divisor

streaming-iterator

Streaming iterators

strength_reduce

Faster integer division and modulus operations

nucleo

plug and play high performance fuzzy matcher

argminmax

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

murmur3

hash

topological-sort

Performs topological sorting

rdrand

random number generator based on rdrand and rdseed instructions

sgp4

A pure Rust implementation of the SGP4 algorithm for satellite propagation

ndarray-linalg

Linear algebra package for rust-ndarray using LAPACK

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

medians

Median, Statistical Measures, Mathematics, Statistics

zipf

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

differential-dataflow

An incremental data-parallel dataflow platform

foldhash

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

special

The package provides special functions

resolvo

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

seahash

A blazingly fast, portable hash function with proven statistical guarantees

sketches-ddsketch

A direct port of the Golang DDSketch implementation

textdistance

Lots of algorithms to compare how similar two sequences are

task-local-extensions

Task-local container for arbitrary data

rand_regex

Generates random strings and byte strings matching a regex

iroh-blobs

blob and collection transfer support for iroh

vek

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

earcutr

port of MapBox's earcut triangulation code to Rust language

simd-adler32

A SIMD-accelerated Adler-32 hash algorithm implementation

rustfst-ffi

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

k

kinematics

daachorse

Double-Array Aho-Corasick

linfa-linalg

Pure-Rust implementation of linear algebra routines for ndarray

memx

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

metrohash

high quality, high performance hash algorithm

reed-solomon-simd

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

GSL

binding for the GSL (the GNU scientific library)

fastcdc

(content defined chunking) in pure Rust

merkle_hash

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

hexf-parse

Parses hexadecimal floats (see also hexf)

reed-solomon-novelpoly

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

genetic_algorithm

A genetic algorithm implementation

hime_redist

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

permutation

Small utility for creating, manipulating, and applying permutations

raft

language implementation of Raft algorithm

transpose

transposing multi-dimensional data

fractional_index

fractional indexing

adler

clean-room implementation of the Adler-32 checksum

ph

data structures based on perfect hashing

glass_pumpkin

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

crossterm_winapi

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

varpro

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

partial_sort

provide a Rust version std::partial_sort

fast_paths

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

gix-negotiate

gitoxide project implementing negotiation algorithms

timely

A low-latency data-parallel dataflow system in Rust

contour

Compute isorings and contour polygons (using marching squares algorithm)

robust

adaptive floating-point predicates for computational geometry

chalk-recursive

Recursive solver for the Chalk project

muldiv

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

levenberg-marquardt

algorithm built on top of nalgebra

rust-stemmers

some popular snowball stemming algorithms

mergable

user-friendly and efficient CRDTs

smawk

Functions for finding row-minima in a totally monotone matrix

simplerand

fast random number generator

levenshtein

algorithm

pocket_prover

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

boyer-moore-magiclen

fast string search algorithm implemented in Rust

cdshealpix

HEALPix tesselation

rithm

Arbitrary precision arithmetic

bm25

BM25 embedder, scorer, and search engine

reactive_graph

A fine-grained reactive graph for building user interfaces

annembed

dimension reduction à la Umap

tantivy-fst

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

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.

keyword_extraction

Collection of algorithms for keyword extraction from text

nanorand

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

ndarray-slice

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

z3

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

quad-rand

Pseudo random implementation with core atomics

radsort

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

blurhash

A pure Rust implementation of blurhash

scru128

Sortable, Clock and Random number-based Unique identifier

dive-deco

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

twofloat

Double-double arithmetic functionality

rand_mt

Reference Mersenne Twister random number generators

quantiles

a collection of approximate quantile algorithms

tailcall

Safe, zero-cost tail recursion

rand_simple

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

arbi

Arbitrary precision integer

chalk-engine

Core trait engine from Chalk project

orx-v

Traits to unify all vectors!

cardinality-estimator

estimating the cardinality of distinct elements in a stream or dataset

timsort

modified MergeSort used in Python and Java

naive_opt

The optimized naive string-search algorithm

clone_dyn

Derive to clone dyn structures

incremental

computations, based on Jane Street's incremental

ddo

generic and efficient framework for MDD-based optimization

rsc_osrm

rust wrapper for osrm, folk from TehGoat/rs_osrm

kd-tree

k-dimensional tree

gxhash

non-cryptographic algorithm

rand_xoshiro

Xoshiro, xoroshiro and splitmix64 random number generators

dec

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

accurate

(more or less) accurate floating point algorithms

mockd

Fake data generator library with 130+ functions

dypdl

Libarary for Dynamic Programming Description Language (DyPDL)

meos

Rust bindings for MEOS C API

byteyarn

hyper-compact strings

probminhash

Minhash algorithms for weighted Jaccard index

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

cam-geom

Geometric models of cameras for photogrammetry

russcip

Rust interface for SCIP

ndarray-rand

Constructors for randomized arrays. rand integration for ndarray.

kube_quantity

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

num-order

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

ipopt

Rust language bindings for the Ipopt non-linear constrained optimization library

murmurhash32

murmurhash32_2

halfbrown

Multi backend HashMap for higher performance on different key space sizes

itermore

🤸‍♀️ More iterator adaptors

cmaes

CMA-ES optimization algorithm

easyfft

providing an easy FFT API for arrays and slices

usearch

Smaller & Faster Single-File Vector Search Engine from Unum

rust-spice

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

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…

dbsp

Continuous streaming analytics engine

integer-sqrt

integer square root algorithm for primitive rust types

cubecl-linalg

CubeCL Linear Algebra Library

fast_polynomial

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

satkit

Satellite Toolkit

pacmap

Pairwise Controlled Manifold Approximation (PaCMAP) for dimensionality reduction

num_convert

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

rustfst

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

adskalman

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

hmac-sha1

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

meta_tools

Collection of general purpose meta tools

sfcgal

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

bit-matrix

bit matrices and vectors

t1ha

T1AH (Fast Positive Hash) hash function

turborand

Fast random number generators

gcra

A basic implementation of GCRA algorithm for rate limiting

petal-neighbors

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

rectangle-pack

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

union-find

Struct and methods for union-find operation

rs-wordle-solver

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

cubecl

Multi-platform high-performance compute language extension for Rust

cap-rand

Capability-based random number generators

raftbare

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

triple_accel

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

alphanumeric-sort

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

interp

Matlab's interp1 function

osqp

(Operator Splitting Quadratic Program) solver

ids_service

that allows to generate unique Ids

radiate

genetic algorithms and artificial evolution

count-min-sketch

Count-min-sketch implementation

arrow-string

String kernels for arrow arrays

glissade

that provides various utilities for animations and transitions

hierarchical_hash_wheel_timer

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

macro-machines

State machine macros with logging and graphviz DOT file generation

rurel

Flexible, reusable reinforcement learning (Q learning) implementation

clingo

Rust idiomatic bindings to the clingo library

version-ranges

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

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.

diff-match-patch-rs

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

extendhash

Rust Hash Extender

relp

Rust Exact Linear Programming

gat-lending-iterator

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

cryptocol

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

metaheuristics-nature

A collection of nature-inspired metaheuristic algorithms

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.

h3o-zip

A compression scheme tailored for H3 cell indexes

graaf

Work with directed graphs

kmeans

Small and fast library for k-means clustering calculations

random_word

Efficient functions for generating random words in many languages

smolprng

A Small and Extensible PRNG written in Rust

adler32

Minimal Adler32 implementation for Rust

fletcher

A dependency free implementation of the Fletcher's checksum algorithm

dilate

A compact, high performance integer dilation library for Rust

tinymt

64/32 - a lightweight variant of Mersenne Twister PRNG

wyrand

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

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

highs

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

kitoken

Fast and versatile tokenizer for language models, supporting BPE, Unigram and WordPiece tokenization

feruca

Unicode Collation Algorithm

nozomi

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

polylog

polylogarithms

vrp-core

A core algorithms to solve a Vehicle Routing Problem

ipl3checksum

calculate the IPL3 checksum for N64 ROMs

color_space

converting between color spaces and comparing colors

mpchash

Multi-probe consistent hashing algorithm implementation

graphalgs

Graph algorithms based on the Rust 'petgraph' library

scnr

Scanner/Lexer with regex patterns and multiple modes

merkle-cbt

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

sequence-generator-rust

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

autour_core

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

hyperloglogplus

HyperLogLog implementations

xxhrs

Safe XXHash and XXH3 bindings

adler2

clean-room implementation of the Adler-32 checksum

wavefc

A home-grown implementation of the Wave Function Collapse algorithm

mesh_to_sdf

Mesh to signed distance field (SDF) converter

contour-isobands

Compute isobands and contour polygons (using marching squares algorithm)

optirustic

A multi-objective optimisation framework for Rust

ran

fast random numbers generation

dogear

merging bookmark trees

treerder

Trie ordering for type implementing Orderable

lt-fm-index

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

general-sam

A general suffix automaton implementation in Rust

kdtree

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

ra_ap_salsa

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

i_triangle

Polygon Triangulation Library: Efficient Delaunay Triangulation for Complex Shapes

logru

A small, embeddable and fast interpreter for a subset of Prolog

starlight

experimental HDL and optimizer for DAGs of lookup tables

rex-sm

Hierarchical state machine

wyhash

fast portable non-cryptographic hashing algorithm and random number generator

crc32-v2

A port of the CRC-32 algorithm to Rust

bevy_lookup_curve

Editable lookup curve for Bevy

many-unzip

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

rdst

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

rgeometry

High-Level Computational Geometry

trie_rcv

Ranked Choice Voting implementation using Tries in Rust

uniset

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

interval_adapter

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

fakeit

Fake data generator library with 130+ functions

jopemachine-raft

language implementation of Raft algorithm

ckey

consistent hash key library

uutils_term_grid

formatting strings into a grid layout. Fork of term_grid.

vecmath

type agnostic library for vector math designed for reexporting

gix-revwalk

providing utilities for walking the revision graph

spc-rs

SPC (Statistical Process Control)

raftpico

Raft framework built on top of the raftbare crate

stringmetrics

approximate string matching

extsort

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

zeros

probability

The package provides a probability-theory toolbox

tiny_sort

Binary-size optimized stable and unstable sorts

chibihash

hash function

timberio/file-source

A high-performance observability data pipeline

risc0-bigint2

RISC Zero's Big Integer Accelerator

line-span

Find line ranges and jump between next and previous lines

iban

IBAN parsing library

opensimplex2

Port of OpenSimplex2

simple_hll

HyperLogLog implementation in rust

ognlib

Some code that is written to practice Rust

s2-tilejson

Backwards compatible JSON format for describing s2 map tilesets

sefar

evolutionary optimization algorithms

geometry-predicates

port of robust geometric predicates

startin

A Delaunay triangulator for terrains

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

rapidhash

port of rapidhash: an extremely fast, high quality, platform-independent hashing algorithm

kewb

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

dotlr

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

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

swift_vec

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

simsearch

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

cyclic-poly-23

A rolling, decomposable hash algorithm

fast-tlsh

generate / parse / compare TLSH locality sensitive hashes

rand_aes

AES based pseudo-random number generator

pathfinding_astar

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

oxidd-reorder

Reordering algorithms for OxiDD

tau-engine

A document tagging library

grid_pathfinding

Pathfinding using JPS and connected components on a grid

seastar

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

importunate

Methods for returning random elements from an iterator

to_shmem

Trait to write to a contiguous chunk of shared memory

kendalls

Kendall's tau rank correlation

hypertwobits

cardinality estimation algorithm

tolerance

Math representation of the physically needed permissible deviation of measures

algorithmica

Rust Algorithms

tinyrand

Lightweight RNG specification and several ultrafast implementations in Rust

times

Timing Benchmark, Repeated Runs, with Statistics

atomic-traits

The traits for generic atomic operations

four-bar

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

counting_sort

Counting sort implementation for Iterators

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'

volute

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

coord2d

rust lib for coordinate in 2d system

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.

bit_gossip

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

graph_process_manager_loggers

Generic loggers for graph_process_manager_core

oefpil

Optimum Estimate of Function Parameters by Iterated Linearization (OEFPIL): Algorithm for nonlinear function fitting to data with errors in both dependent and independent variables where correlation…

conhash

Consistent Hashing library in Rust

mutcursor

Safely stores mutable references to parent nodes, for backtracking during traversal of tree & graph structures

rake

Rapid Automatic Keyword Extraction (RAKE) algorithm

ultrasonic

Transactional execution layer with capability-based memory access for zk-AluVM

easer

Tiny library imlementing Robert Penner's easing functions

RustQuant_math

quantitative finance

rollgrid

pseudo-infinite open worlds

multistochgrad

Stochastic Gradient, Multithreaded

eta-algorithms

Low overhead data structures focused on performance

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…

whittaker-eilers

A sparse matrix implementation of Whittaker-Eilers smoothing and interpolation

sobol_burley

A seedable Owen-scrambled Sobol sequence

flo_binding

Declarative binding library for Rust

english-to-cron

converts natural language into cron expressions

crunch

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

rust_intervals

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

voxell_rng

Cheap and dirty thread-local RNGs

mt19937

A translation of the MT19937 Mersenne Twister rng algorithm to Rust

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…

line-clipping

implementing line clipping algorithms

edfsm

Event Driven Finite State Machine library

vector_quantizer

vector quantization utilities and functions

drain_filter_polyfill

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

reveler

A cryptographic commitment scheme based on lattice and parallelized matrix-vector multiplication

product-os-random

Product OS : Random provides a suite of random generator tools for different contexts. This includes random text, number and key generators including crypotgraphically secure random generation.

nlopt

Wrapper for the nlopt library

louvre

A Robust Triangulation Algorigthm

anim8

Animation toolset

relp-num

Number types for the relp crate

controlled_astar

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

list_math

doing math on a list including average, smallest, largest, and standard deviation

ragged-buffer

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

backyard-generator

Convert AST node back to PHP code

hnsw_rs

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

random-pick

Pick an element from a slice randomly by given weights

count-digits

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

tf-binding-rs

Fast transcription factor binding site prediction and FASTA manipulation in Rust

round_robin

Create a vector of rounds and their respective matches in a tournament, using the Round-robin algorithm

solaris-rs

predict the position of the Sun

truck-polymesh

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

permutohedron

Generate permutations of sequences. Either lexicographical order permutations, or a minimal swaps permutation sequence implemented using Heap's algorithm.

dynalgo

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

lazyrand

generating random numbers easily

syntree_layout

visualize trees from the 'syntree' crate

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…