Lib.rs

rand

Random number generators and other randomness functionality

itertools

Extra iterator adaptors, iterator methods, free functions, and macros

twox-hash

XXHash and XXH3 algorithms

phf

Runtime support for perfect hash function data structures

strsim

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

fastrand

fast random number generator

ahash

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

crc

support of various standards

xxhash-rust

xxhash

rustfft

High-performance FFT library written in pure Rust

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…

scroll

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

ff

building and interfacing with finite fields

rand_xoshiro

Xoshiro, xoroshiro and splitmix64 random number generators

rstar

An R*-tree spatial index

fnv

Fowler–Noll–Vo hash function

realfft

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

streaming-iterator

Streaming iterators

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.

ulid

a Universally Unique Lexicographically Sortable Identifier implementation

noise

Procedural noise generation library

ndarray-linalg

Linear algebra package for rust-ndarray using LAPACK

siphasher

SipHash-2-4, SipHash-1-3 and 128-bit variants in pure Rust

dissimilar

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

rand_distr

Sampling from random number distributions

highway

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

bytecount

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

pathfinding

flow, and graph algorithms

extendr-api

Safe and user friendly bindings to the R programming language

kiddo

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

ena

Union-find, congruence closure, and other unification code. Based on code from rustc.

passwords

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

foldhash

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

wildmatch

string matching with single- and multi-character wildcard operator

pulp

Safe generic simd

nonmax

Numeric types that cannot hold maximum values

crunchy

unroller: deterministically unroll constant loops

crc32c

Safe implementation for hardware accelerated CRC32C instructions with software fallback

gcd

Calculate the greatest common divisor

rs_merkle

The most advanced Merkle Tree library for Rust. Supports creating and verifying proofs, multi-proofs, as well as advanced features, such as tree diffs, transactional changes, and rollbacks

topological-sort

Performs topological sorting

gix-revwalk

providing utilities for walking the revision graph

edit-distance

Levenshtein edit distance between strings, a measure for similarity

murmur3

hash

aligned-vec

Aligned vector and box containers

treediff

Find the difference between arbitrary data structures

special

The package provides special functions

medians

Median, Statistical Measures, Mathematics, Statistics

rapidhash

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

rustfst

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

rand_regex

Generates random strings and byte strings matching a regex

timely

A low-latency data-parallel dataflow system in Rust

slice-group-by

Iterators over groups in slices and strs

strength_reduce

Faster integer division and modulus operations

sgp4

A pure Rust implementation of the SGP4 algorithm for satellite propagation

iter-read

A Read implementation for iterators over u8 and related types

argminmax

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

simd-adler32

A SIMD-accelerated Adler-32 hash algorithm implementation

phf_codegen

Codegen library for PHF types

textdistance

Lots of algorithms to compare how similar two sequences are

earcutr

port of MapBox's earcut triangulation code to Rust language

differential-dataflow

An incremental data-parallel dataflow platform

mt19937

A translation of the MT19937 Mersenne Twister rng algorithm to Rust

resolvo

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

memx

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

seahash

A blazingly fast, portable hash function with proven statistical guarantees

gxhash

non-cryptographic algorithm

metrohash

high quality, high performance hash algorithm

vek

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

rand_hc

HC128 random number generator

blake2_bin

a command line implementation of BLAKE2b/s/bp/sp and all their parameters

feanor-math

number theory, providing implementations for arithmetic in various rings and algorithms working on them

adler

clean-room implementation of the Adler-32 checksum

merkle_hash

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

fastcdc

(content defined chunking) in pure Rust

levenshtein

algorithm

rand_jitter

Random number generator based on timing jitter

skillratings

Calculate a player's skill rating using algorithms like Elo, Glicko, Glicko-2, TrueSkill and many more

ostree-ext

Extension APIs for OSTree

rand_mt

Reference Mersenne Twister random number generators

const-random

compile time random number generation

hexf-parse

Parses hexadecimal floats (see also hexf)

advent-of-code

Solutions to Advent of Code

jubjub

elliptic curve group

k

kinematics

gemm

Playground for matrix multiplication algorithms

sketches-ddsketch

A direct port of the Golang DDSketch implementation

arroy

Annoy-inspired Approximate Nearest Neighbors in Rust, based on LMDB and optimized for memory usage

alphanumeric-sort

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

genetic_algorithms

solving genetic algorithm problems

bm25

BM25 embedder, scorer, and search engine

yada

double-array trie library aiming for fast search and compact data representation

hnsw_rs

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

simplerand

fast random number generator

kdtree

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

ph

data structures based on perfect hashing

geo-clipper

Boolean operations on polygons

cardinality-estimator

estimating the cardinality of distinct elements in a stream or dataset

partial_sort

provide a Rust version std::partial_sort

reed-solomon-simd

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

mod_interface

Protocol of modularity unifying interface of a module and introducing layers

flo_curves

manipulating Bezier curves

rphonetic

Rust port of phonetic Apache commons-codec algorithms

reed-solomon-novelpoly

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

fractional_index

fractional indexing

forust-ml

A lightweight gradient boosting implementation in Rust

GSL

binding for the GSL (the GNU scientific library)

hime_redist

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

interp

Matlab's interp1 function

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.

cuvs

RAPIDS vector search library

ndarray-slice

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

grb

API for Gurobi optimizer

integer-sqrt

integer square root algorithm for primitive rust types

osqp

(Operator Splitting Quadratic Program) solver

pubgrub

version solving algorithm

mergable

user-friendly and efficient CRDTs

daachorse

Double-Array Aho-Corasick

raft

language implementation of Raft algorithm

tenthash

A high-quality, non-cryptographic, 160-bit hash function

deep_causality

Computational causality library. Provides causality graph, collections, context and causal reasoning.

cubecl-linalg

CubeCL Linear Algebra Library

nanorand

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

keyword_extraction

Collection of algorithms for keyword extraction from text

levenberg-marquardt

algorithm built on top of nalgebra

avalog

An experimental implementation of Avatar Logic with a Prolog-like syntax

boyer-moore-magiclen

fast string search algorithm implemented in Rust

transpose

transposing multi-dimensional data

lilt

running interruptable, transition based animations as a function of time

blstrs_plus

High performance implementation of BLS12 381

guacamole

linearly-seekable random number generator

fast_paths

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

dmp

A high-performance library in that manipulates plain text

radsort

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

quantiles

a collection of approximate quantile algorithms

bitm

bit and bitmap (bit vector) manipulation

russcip

Rust interface for SCIP

wyrand

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

naive_opt

The optimized naive string-search algorithm

robust

adaptive floating-point predicates for computational geometry

twofloat

Double-double arithmetic functionality

glass_pumpkin

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

knossos

generating and rendering mazes

genetic_algorithm

A genetic algorithm implementation

scru128

Sortable, Clock and Random number-based Unique identifier

kube_quantity

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

murmurhash32

murmurhash32_2

smawk

Functions for finding row-minima in a totally monotone matrix

accurate

(more or less) accurate floating point algorithms

nlopt

Wrapper for the nlopt library

dive-deco

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

caches

popular caches (support no_std)

cggmp21

TSS ECDSA implementation based on CGGMP21 paper

highs

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

graph

high-performant graph algorithms

s2-tilejson

Backwards compatible JSON format for describing s2 map tilesets

orx-v

Traits to unify all vectors!

z3

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

optirustic

A multi-objective optimisation framework for Rust

ipopt

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

union-find

Struct and methods for union-find operation

glissade

that provides various utilities for animations and transitions

tailcall

Safe, zero-cost tail recursion

linestring

line string toolbox

par-iter

Fork of rayon, with chili support

cam-geom

Geometric models of cameras for photogrammetry

hierarchical_hash_wheel_timer

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

four-bar

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

oxyroot

attempt to make library reading and writing of .root binary files which are commonly used in particle physics

muldiv

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

ltpp-output

An atomic output library based on Rust that supports output functionalities through functions, builders, and other methods. It allows customization of text and background colors.

supercluster

Geospatial and non-geospatial point clustering

bevy_knossos

generating and rendering mazes

version-ranges

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

incremental

computations, based on Jane Street's incremental

secret-santa-rs

Generator for who buys for who in a secret santa

ndarray-rand

Constructors for randomized arrays. rand integration for ndarray.

scnr

Scanner/Lexer with regex patterns and multiple modes

general-sam

A general suffix automaton implementation in Rust

trackball

Virtual Trackball Orbiting via the Exponential Map

petal-neighbors

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

fletcher

A dependency free implementation of the Fletcher's checksum algorithm

moc

made to create and manipulate HEALPix Multi-Order Coverages maps (MOCs), see https://ivoa.net/documents/MOC/

rsc_osrm

rust wrapper for osrm, folk from TehGoat/rs_osrm

rectangle-pack

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

metatensor

Self-describing sparse tensor data format for atomistic machine learning and beyond

rs-stats

Statistics library in rust

tantivy-fst

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

arpfloat

Arbitrary-precision floating point library

soa-rs

A Vec-like structure-of-arrays container

xgraph

A comprehensive Rust library providing efficient graph algorithms for solving real-world problems in social network analysis, transportation optimization, recommendation systems, and more

pmcore

building blocks needed to create new Non-Parametric algorithms and its integration with Pmetrics

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

mini-mcmc

A compact Rust library for Markov Chain Monte Carlo (MCMC) methods with GPU support

rustfst-ffi

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

num_convert

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

ceres-solver

Safe Rust bindings for the Ceres Solver

cubecl-reduce

CubeCL Reduce Algorithms

dypdl-heuristic-search

Heuristic search solvers for Dynamic Programming Description Language (DyPDL)

simplehash

fast Rust library implementing common non-cryptographic hash functions: FNV, MurmurHash3, CityHash, and Rendezvous hashing

rucrf

Conditional Random Fields implemented in pure Rust

dbsp

Continuous streaming analytics engine

probminhash

Minhash algorithms for weighted Jaccard index

error_tools

Basic exceptions handling mechanism

diffusionx

random number/stochastic process simulation with high performance

alot

A forbid-unsafe, generational slot map with usize-sized IDs

conv2

number of conversion traits with more specific semantics than those provided by 'as' or 'From'/'Into'

entropy-map

Ultra-low latency hash map using minimal perfect hash functions and compact encoding of values, minimizing memory footprint and storage size for efficient data retrieval

quad-rand

Pseudo random implementation with core atomics

scirs2-optimize

Optimization module for SciRS2

fast_hilbert

Fast Hilbert 2D curve computation using an efficient Lookup Table (LUT)

timsort

modified MergeSort used in Python and Java

feos-campd

Computer-aided molecular and process design using the FeOs framework

atomic-traits

The traits for generic atomic operations

nanoid

A tiny, secure, URL-friendly, unique string ID generator for Rust

toodee

A lightweight 2D wrapper around a Vec

lt-fm-index

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

gat-lending-iterator

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

itermore

🤸‍♀️ More iterator adaptors

radiate

genetic algorithms and artificial evolution

bridgetree

A space-efficient Merkle tree designed for linear appends with witnessing of marked leaves, checkpointing & state restoration

random_color

generating random attractive colors

graaf

Work with directed graphs

oxirush-nas

5G NAS Message encoder/decoder library

ta

Technical analysis library. Implements number of indicators: EMA, SMA, RSI, MACD, Stochastic, etc.

rollgrid

pseudo-infinite open worlds

rand_simple

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

algos

A collection of algorithms in Rust

adler32

Minimal Adler32 implementation for Rust

i_triangle

Polygon Triangulation Library: Efficient Delaunay Triangulation for Complex Shapes

ids_service

that allows to generate unique Ids

bit-matrix

bit matrices and vectors

feruca

Unicode Collation Algorithm

mhgl

Matts HyperGraph Library (MHGL). A straightforward library for hypergraph datastructures.

augurs

A time-series toolkit for forecasting, outlier detection, clustering and more

meos

Rust bindings for MEOS C API

rhai-sci

Scientific computing in the Rhai scripting language

ddo

generic and efficient framework for MDD-based optimization

geometry-predicates

port of robust geometric predicates

coord2d

rust lib for coordinate in 2d system

syntree_layout

visualize trees from the 'syntree' crate

color_space

converting between color spaces and comparing colors

bit_gossip

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

panfix

parsing: linear time parsing of multifix operators

annembed

dimension reduction à la Umap

wcs

FITS World Coordinate System (WCS)

easyfft

providing an easy FFT API for arrays and slices

haru_cmaes

CMA-ES optimization algorithm implementation based on Hansen's purecma Python implementation

kasuari

layout solver for GUIs, based on the Cassowary algorithm. A fork of the unmaintained cassowary-rs crate with improvments and bug fixes. Kasuari is the indonesian name for the cassowary bird

unty

Explicitly types your generics

broccoli

broadphase collision detection algorithms

cdshealpix

HEALPix tesselation

pyimports

Parse and analyze the imports within a python package

here_be_dragons

Map generator for games

rdst

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

smolprng

A Small and Extensible PRNG written in Rust

rithm

Arbitrary precision arithmetic

fast_poisson

Bridson's algorithm for fast Poisson disk sampling

kd-tree

k-dimensional tree

zspell

Native Rust library for spellchecking

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.

bit-iter

Iterate forward or backwards over the positions of set bits in a word

od_opencv

Object detection utilities in Rust programming language for YOLO-based neural networks in OpenCV ecosystem

vrp-core

A core algorithms to solve a Vehicle Routing Problem

count-min-sketch

Count-min-sketch implementation

chronologic

Time constraint reasoning (scheduling...)

shor

Shor's factoring algorithm written in rust

mpchash

Multi-probe consistent hashing algorithm implementation

xiangting

calculating the deficiency number (a.k.a. xiangting number, 向聴数).

xxhrs

Safe XXHash and XXH3 bindings

polygons

Fast points-in-polygon test and distances to polygons

dlx-rs

dancing links in Rust

volute

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

rs-wordle-solver

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

stringmetrics

approximate string matching

clingo

Rust idiomatic bindings to the clingo library

bpe-openai

Prebuilt fast byte-pair encoders for OpenAI

h3o-zip

A compression scheme tailored for H3 cell indexes

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

simsearch

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

layer-proc-gen

easy to use chunk based procedural generation library with top-down planning

hronn

An experimental CNC toolpath generator

crc32-v2

A port of the CRC-32 algorithm to Rust

linfa-linalg

Pure-Rust implementation of linear algebra routines for ndarray

edfsm

Event Driven Finite State Machine library

pyinrs

type library that is as easy to use as Python built-in types

sorted-insert

traits to insert elements to a sorted collection and keep the order

glicko_2

Glicko2 is an iterative algorithm for ranking opponents or teams in 1v1 games

rust_intervals

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

clipper2

A polygon Clipping and Offsetting library for Rust

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

randevu

The official Rust implementation of the RANDEVU algorithm

i_shape

iShape is a compact and efficient library specifically designed for representing 2D data structures using IntPoint

rocm-rs

Rust bindings for AMD ROCm libraries

pm-remez

Parks-McClellan Remez FIR design algorithm

clone_dyn

Derive to clone dyn structures

graph-algorithms-rs

A collection of graph algorithms

wavefc

A home-grown implementation of the Wave Function Collapse algorithm

importunate

Methods for returning random elements from an iterator

sfcgal

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

sefar

evolutionary optimization algorithms

nabla-ml

A numpy-like library for Rust

rust-spice

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

docker-image

no_std-compatible Docker image reference parser with strict adherence to Docker's naming rules

t1ha

T1AH (Fast Positive Hash) hash function

graphrs

package for the creation, manipulation and analysis of graphs

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'

jismesh

handling and converting JIS X0410 area mesh codes

fastatomstruct

A Python package for the analysis of atomic structures and dynamics

brique-rs

A MLP library made from scratch, using the rust standard lib

timberio/file-source

A high-performance observability data pipeline

moongraph

Schedules and runs DAGs accessing shared resources. 🌙

density-rs

Superfast compression library

permutation

Small utility for creating, manipulating, and applying permutations

tolerance

Math representation of the physically needed permissible deviation of measures

ognlib

Some code that is written to practice Rust

dilate

A compact, high performance integer dilation library for Rust

lp-solvers

.lp file format implementation and external solver invocation for Cbc, Gurobi, cplex, and GLPK

libsufr

Parallel Construction of Suffix Arrays in Rust

jawe-cuvs-iii

RAPIDS vector search library

liba

An algorithm library based on C/C++

cast

Ergonomic, checked cast functions for primitive types

arbi

Arbitrary Precision Integer

numext-fixed-uint

Fixed-size uint types

jopemachine-raft

language implementation of Raft algorithm

sonic-api

API for formally-verifiable distributed contracts

hyper_byte

An unsafe, near-zero cost (1-2 instructions) byte transmuter to numeric types with fast byte reader

pharmsol

solving analytic and ode-defined pharmacometric models

hashinator

identify hashes blazingly fast

fugue

A binary analysis framework written in Rust

keyforge95

product key generation / validation for Windows 95 and other Microsoft products

uniset

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

time_series_generator

Generate various timeseries of given length, some randomly sampled

urandom

Produce and consume randomness, to convert them to useful types and distributions, and some randomness-related algorithms

lutz

"An Algorithm for the Real Time Analysis of Digitised Images" by R. K. Lutz

lazyrand

generating random numbers easily

acap

As Close As Possible — nearest neighbor search in Rust

collate

Traits and a data structure to support collation and bisection

merkle-cbt

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

geos-sys

GEOS C API bindings

localsearch

Local Search based Metaheuristics

probability

The package provides a probability-theory toolbox

easer

Tiny library imlementing Robert Penner's easing functions

crunch

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

quine-mccluskey

Boolean function minimizer based on Quine–McCluskey algorithm

tetengo_lattice

Viterbi search and A* algorithm implementation

geomorph

conversion between different coordinate systems

cmsketch

A count min sketch implementation in Rust

basic_dsp

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

datas

data structures and algorithms and data analisys

seastar

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

out

fast min and max functionality for collections

blosc

Rust bindings to the C-BLOSC compression library

iterate-trait

Experiment with methods on IntoIterator

algorithmica

Rust Algorithms

btree_experiment

implements a BTreeMap similar to std::collections::BTreeMap

natord

Natural ordering for Rust

abd-clam

Clustering, Learning and Approximation with Manifolds

sif-embedding

Smooth inverse frequency (SIF), a simple but powerful embedding technique for sentences

hud-slice-by-8

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

turborand

Fast random number generators

f3l_segmentation

3D Point Cloud Library

extendhash

Rust Hash Extender

b10

Lossless handling of decimal numbers at maximum performance

libecvrf

A ECVRF that's friendly with EVM, based on curve secp256k1 and keccak256

markov_namegen

Random text generators based on Markov models

noise-functions

A collection of fast and lightweight noise functions

boomphf

Scalable and Efficient Minimal Perfect Hash Functions

cmaes

CMA-ES optimization algorithm

zeros

treerder

Trie ordering for type implementing Orderable

wows_replays

A parser for World of Warships replay files

fts-solver

A reference solver for flow trading optimization

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…