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.

fastrand

fast random number generator

crc

support of various standards

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

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

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

pathfinding

flow, and graph algorithms

kiddo

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

ff

building and interfacing with finite fields

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.

passwords

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

realfft

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

daachorse

Double-Array Aho-Corasick

uint

Large fixed-size integer arithmetic

strength_reduce

Faster integer division and modulus operations

gcd

Calculate the greatest common divisor

oorandom

A tiny, robust PRNG implementation

streaming-iterator

Streaming iterators

rdrand

random number generator based on rdrand and rdseed instructions

topological-sort

Performs topological sorting

rand_hc

HC128 random number generator

nucleo

plug and play high performance fuzzy matcher

sgp4

A pure Rust implementation of the SGP4 algorithm for satellite propagation

robust

adaptive floating-point predicates for computational geometry

murmur3

hash

differential-dataflow

An incremental data-parallel dataflow platform

treediff

Find the difference between arbitrary data structures

buffer-redux

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

edit-distance

Levenshtein edit distance between strings, a measure for similarity

easy-smt

Easily interact with an smt solver as a subprocess

rustfst

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

ndarray-linalg

Linear algebra package for rust-ndarray using LAPACK

medians

Median, Statistical Measures, Mathematics, Statistics

argminmax

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

textdistance

Lots of algorithms to compare how similar two sequences are

zipf

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

sketches-ddsketch

A direct port of the Golang DDSketch implementation

resolvo

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

task-local-extensions

Task-local container for arbitrary data

GSL

binding for the GSL (the GNU scientific library)

simd-adler32

A SIMD-accelerated Adler-32 hash algorithm implementation

seahash

A blazingly fast, portable hash function with proven statistical guarantees

slice-group-by

Iterators over groups in slices and strs

reed-solomon-novelpoly

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

memx

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

fastcdc

(content defined chunking) in pure Rust

linfa-linalg

Pure-Rust implementation of linear algebra routines for ndarray

earcutr

port of MapBox's earcut triangulation code to Rust language

glass_pumpkin

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

jubjub

elliptic curve group

radsort

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

z3

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

nanorand

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

hexf-parse

Parses hexadecimal floats (see also hexf)

genetic_algorithm

A genetic algorithm implementation

hime_redist

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

raft

language implementation of Raft algorithm

reed-solomon-simd

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

ndarray-rand

Constructors for randomized arrays. rand integration for ndarray.

adler

clean-room implementation of the Adler-32 checksum

chalk-recursive

Recursive solver for the Chalk project

arrow-select

Selection kernels for arrow arrays

merkle_hash

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

muldiv

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

varpro

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

contour

Compute isorings and contour polygons (using marching squares algorithm)

fractional_index

fractional indexing

foldhash

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

ph

data structures based on perfect hashing

k

kinematics

crossterm_winapi

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

kd-tree

k-dimensional tree

fakeit

Fake data generator library with 130+ functions

fast_paths

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

levenberg-marquardt

algorithm built on top of nalgebra

special

The package provides special functions

vek

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

smawk

Functions for finding row-minima in a totally monotone matrix

levenshtein

algorithm

keyword_extraction

Collection of algorithms for keyword extraction from text

rust-stemmers

some popular snowball stemming algorithms

tailcall

Safe, zero-cost tail recursion

tantivy-fst

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

quad-rand

Pseudo random implementation with core atomics

annembed

dimension reduction à la Umap

rand_mt

Reference Mersenne Twister random number generators

cdshealpix

HEALPix tesselation

chalk-engine

Core trait engine from Chalk project

gix-negotiate

gitoxide project implementing negotiation algorithms

boyer-moore-magiclen

fast string search algorithm implemented in Rust

arrow-ord

Ordering kernels for arrow arrays

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)

naive_opt

The optimized naive string-search algorithm

timsort

modified MergeSort used in Python and Java

rand_regex

Generates random strings and byte strings matching a regex

dive-deco

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

ddo

generic and efficient framework for MDD-based optimization

rand_simple

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

quantiles

a collection of approximate quantile algorithms

cam-geom

Geometric models of cameras for photogrammetry

scru128

Sortable, Clock and Random number-based Unique identifier

dec

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

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

rithm

Arbitrary precision arithmetic

itermore

🤸‍♀️ More iterator adaptors

integer-sqrt

integer square root algorithm for primitive rust types

meos

Rust bindings for MEOS C API

gxhash

non-cryptographic algorithm

reactive_graph

A fine-grained reactive graph for building user interfaces

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.

t1ha

T1AH (Fast Positive Hash) hash function

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…

accurate

(more or less) accurate floating point algorithms

transpose

transposing multi-dimensional data

mockd

Fake data generator library with 130+ functions

byteyarn

hyper-compact strings

kube_quantity

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

incremental

computations, based on Jane Street's incremental

qwt

Quad Wavelet Tree

usearch

Smaller & Faster Single-File Vector Search Engine from Unum

clingo

Rust idiomatic bindings to the clingo library

russcip

Rust interface for SCIP

fast_polynomial

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

ids_service

that allows to generate unique Ids

graaf

Work with directed graphs

probminhash

Minhash algorithms for weighted Jaccard index

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.

rust-spice

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

ran

fast random numbers generation

murmurhash32

murmurhash32_2

timely

A low-latency data-parallel dataflow system in Rust

meta_tools

Collection of general purpose meta tools

interp

Matlab's interp1 function

num_convert

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

highs

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

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

rectangle-pack

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

rs-wordle-solver

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

fuzzy-muff

Fuzzy Matching Library

gcra

A basic implementation of GCRA algorithm for rate limiting

turborand

Fast random number generators

triple_accel

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

lazy-bytes-cast

Lazy casts from & to byte arrays

relp

Rust Exact Linear Programming

qr2term

Stupidly simple Rust crate to render a QR code in the terminal

random_word

Efficient functions for generating random words in many languages

dbsp

Continuous streaming analytics engine

tinymt

64/32 - a lightweight variant of Mersenne Twister PRNG

iroh-blobs

blob and collection transfer support for iroh

adler2

clean-room implementation of the Adler-32 checksum

av-metrics

A collection of algorithms for measuring audio/video metrics

float_next_after

A trait for native rust f64/f32 nextafter

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.

kdtree

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

starlight

experimental HDL and optimizer for DAGs of lookup tables

vrp-core

A core algorithms to solve a Vehicle Routing Problem

fletcher

A dependency free implementation of the Fletcher's checksum algorithm

dilate

A compact, high performance integer dilation library for Rust

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

rurel

Flexible, reusable reinforcement learning (Q learning) implementation

hmac-sha1

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

smolprng

A Small and Extensible PRNG written in Rust

cubecl

Multi-platform high-performance compute language extension for Rust

wyrand

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

rust-analyzer-salsa

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

cap-rand

Capability-based random number generators

nozomi

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

color_space

converting between color spaces and comparing colors

hnsw_rs

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

satkit

Satellite Toolkit

gat-lending-iterator

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

metaheuristics-nature

A collection of nature-inspired metaheuristic algorithms

cubecl-linalg

CubeCL Linear Algebra Library

rex-sm

Hierarchical state machine

easyfft

providing an easy FFT API for arrays and slices

lt-fm-index

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

jopemachine-raft

language implementation of Raft algorithm

hierarchical_hash_wheel_timer

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

extsort

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

diff-match-patch-rs

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

alphanumeric-sort

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

cryptocol

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

merkle-cbt

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

mesh_to_sdf

Mesh to signed distance field (SDF) converter

contour-isobands

Compute isobands and contour polygons (using marching squares algorithm)

trie_rcv

Ranked Choice Voting implementation using Tries in Rust

wyhash

fast portable non-cryptographic hashing algorithm and random number generator

gix-revwalk

providing utilities for walking the revision graph

dogear

merging bookmark trees

polylog

polylogarithms

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 )

yara-x-parser

A parsing library for YARA rules

bit_gossip

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

startin

A Delaunay triangulator for terrains

general-sam

A general suffix automaton implementation in Rust

uutils_term_grid

formatting strings into a grid layout. Fork of term_grid.

tiny_sort

Binary-size optimized stable and unstable sorts

graph-algorithms-rs

A collection of graph algorithms

pasture-algorithms

Point cloud algorithms for pasture

cyclic-poly-23

A rolling, decomposable hash algorithm

rust_intervals

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

xxhrs

Safe XXHash and XXH3 bindings

autour_core

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

tau-engine

A document tagging library

probability

The package provides a probability-theory toolbox

pg_task

Resumable state machine based Postgres tasks

sequence-generator-rust

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

rdst

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

zeros

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.

sfcgal

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

rand_chacha

ChaCha random number generator

raftbare

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

iban

IBAN parsing 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

uniset

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

scnr

Scanner/Lexer with regex patterns and multiple modes

line-span

Find line ranges and jump between next and previous lines

ra_ap_salsa

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

d3_geo_voronoi_rs

A port into rustlang of the javascript library d3-geo-voronoi

simsearch

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

density-rs

Superfast compression library

wavefc

A home-grown implementation of the Wave Function Collapse algorithm

incrementalmerkletree-testing

Common types, interfaces, and utilities for testing Merkle tree data structures

moonshine-behavior

Minimalistic state machine for Bevy game engine

conhash

Consistent Hashing library in Rust

kmeans

Small and fast library for k-means clustering calculations

jaime

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

counting_sort

Counting sort implementation for Iterators

vecmath

type agnostic library for vector math designed for reexporting

rgeometry

High-Level Computational Geometry

simple_hll

HyperLogLog implementation in rust

stringmetrics

approximate string matching

timberio/file-source

A high-performance observability data pipeline

kendalls

Kendall's tau rank correlation

kewb

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

nlopt

Wrapper for the nlopt library

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

sigmah

Create and scan binary signature in Rust efficiently

swift_vec

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

drain_filter_polyfill

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

pathfinding_astar

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

ckey

consistent hash key library

to_shmem

Trait to write to a contiguous chunk of shared memory

opis

rational number and matrix arithmetic

natord

Natural ordering for Rust

grid_pathfinding

Pathfinding using JPS and connected components on a grid

importunate

Methods for returning random elements from an iterator

pumpkin-solver

The Pumpkin combinatorial optimisation solver library

geo-clipper

Boolean operations on polygons

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

tolerance

Math representation of the physically needed permissible deviation of measures

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'

fast-tlsh

generate / parse / compare TLSH locality sensitive hashes

times

Timing Benchmark, Repeated Runs, with Statistics

qptrie

A QP-Trie implementation for Rust

four-bar

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

count-digits

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

num-order

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

regexsolver

Manipulate regex and automaton as if they were sets

pyin

pYIN pitch detection algorithm written in Rust

graph_process_manager_loggers

Generic loggers for graph_process_manager_core

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…

multistochgrad

Stochastic Gradient, Multithreaded

bpcon

Byzantine Fault-Tolerant Consensus Protocol Implementation in Rust

convolve2d

Easy and extensible pure rust image convolutions

s2-tilejson

Backwards compatible JSON format for describing s2 map tilesets

rand_jitter

Random number generator based on timing jitter

hypertwobits

cardinality estimation algorithm

bpe-tokenizer

A BPE Tokenizer 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…

relp-num

Number types for the relp crate

sobol_burley

A seedable Owen-scrambled Sobol sequence

recursive

Easy recursion without stack overflows

rufl

A powerful util function library for rust

hud-slice-by-8

HUD Software's Rust improved implementation of the Intel Slice-By-8 algorithm

augurs-dtw

Dynamic Time Warping (DTW) algorithm for Rust

programinduction

program induction and learning representations

seastar

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

mutcursor

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

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…

rand_aes

AES based pseudo-random number generator

flo_binding

Declarative binding library for Rust

dynalgo

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

explicit-endian

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

pacmap

Pairwise Controlled Manifold Approximation (PaCMAP) for dimensionality reduction

algorithmica

Rust Algorithms

openraft-sledstore

A sled based implementation of the openraft::RaftStorage trait

easer

Tiny library imlementing Robert Penner's easing functions

is-tree

Everything is a tree

ragged-buffer

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

tinyrand

Lightweight RNG specification and several ultrafast implementations in Rust

dredd-rs

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

solaris-rs

predict the position of the Sun

zorder

Fast Z-order curve conversions

mpchash

Multi-probe consistent hashing algorithm implementation

fastlem

generating procedural terrains based on simplified landscape evolution model (LEM)

oxidd-reorder

Reordering algorithms for OxiDD

bm25

BM25 embedder and search engine

rectutils

Common algorithms for rectangles (quadtree, rect packing, etc.)

mt19937

A translation of the MT19937 Mersenne Twister rng algorithm to Rust

line_drawing

A collection of line-drawing algorithms for use in graphics and video games

rake

Rapid Automatic Keyword Extraction (RAKE) algorithm

louvre

A Robust Triangulation Algorigthm

repath

A fast pathfinding library using A* algorithm, caching, precomputation and path segmentation with concurrent pathfinding

partial_sort

version of std::partial_sort

hyperloglog

in Rust

tofas

Translation of fundamental astronomical subroutines

randevu

The official Rust implementation of the RANDEVU algorithm

moga

A multi-objective genetic algorithm framework

permutohedron

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

arrow-string

String kernels for arrow arrays

probabilistic_bisector

bisection for one-dimensional functions in the presence of noise

nu_plugin_hashes

A Nushell plugin that adds 61 cryptographic hash functions from Hashes project

flat_spatial

Flat spatial partitionning algorithms and data structures

doers

generating Design Of Experiments (DOE)

weighted_rand

A weighted random sampling crate using Walker's Alias Method

random-pick

Pick an element from a slice randomly by given weights

bit-matrix

bit matrices and vectors

distances

Fast and generic distance functions for high-dimensional data

tdigests

An efficient Rust implementation of the t-digest algorithm

lilt

dependency free library for running interruptable, transition based animations as a function of time

feruca

Unicode Collation Algorithm

rollgrid

pseudo-infinite open worlds

setsum

order-agnostic checksum

fixed32-math

Geometric types

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

syntree_layout

visualize trees from the 'syntree' crate

futf

Handling fragments of UTF-8

spiral

Iterate over a 2D structure in a spiral pattern