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

realfft

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

streaming-iterator

Streaming iterators

fnv

Fowler–Noll–Vo hash function

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

differential-dataflow

An incremental data-parallel dataflow platform

medians

Median, Statistical Measures, Mathematics, Statistics

rapidhash

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

rand_regex

Generates random strings and byte strings matching a regex

rustfst

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

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

earcutr

port of MapBox's earcut triangulation code to Rust language

textdistance

Lots of algorithms to compare how similar two sequences are

mt19937

A translation of the MT19937 Mersenne Twister rng algorithm to Rust

rphonetic

Rust port of phonetic Apache commons-codec algorithms

timely

A low-latency data-parallel dataflow system in Rust

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

rand_jitter

Random number generator based on timing jitter

levenshtein

algorithm

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

arroy

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

resolvo

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

pubgrub

version solving algorithm

sketches-ddsketch

A direct port of the Golang DDSketch implementation

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

simplerand

fast random number generator

ph

data structures based on perfect hashing

kdtree

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

geo-clipper

Boolean operations on polygons

cardinality-estimator

estimating the cardinality of distinct elements in a stream or dataset

interp

Matlab's interp1 function

hnsw_rs

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

partial_sort

provide a Rust version std::partial_sort

flo_curves

manipulating Bezier curves

reed-solomon-simd

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

fractional_index

fractional indexing

reed-solomon-novelpoly

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

forust-ml

A lightweight gradient boosting implementation in Rust

GSL

binding for the GSL (the GNU scientific library)

mod_interface

Protocol of modularity unifying interface of a module and introducing layers

hime_redist

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

cuvs

RAPIDS vector search library

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.

integer-sqrt

integer square root algorithm for primitive rust types

osqp

(Operator Splitting Quadratic Program) solver

grb

API for Gurobi optimizer

ndarray-slice

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

mergable

user-friendly and efficient CRDTs

raft

language implementation of Raft algorithm

basic_dsp_vector

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

tenthash

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

daachorse

Double-Array Aho-Corasick

deep_causality

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

nanorand

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

cubecl-linalg

CubeCL Linear Algebra Library

levenberg-marquardt

algorithm built on top of nalgebra

keyword_extraction

Collection of algorithms for keyword extraction from text

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

blstrs_plus

High performance implementation of BLS12 381

lilt

running interruptable, transition based animations as a function of time

dbsp

Continuous streaming analytics engine

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

radsort

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

naive_opt

The optimized naive string-search algorithm

russcip

Rust interface for SCIP

quantiles

a collection of approximate quantile algorithms

wyrand

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

bitm

bit and bitmap (bit vector) manipulation

robust

adaptive floating-point predicates for computational geometry

twofloat

Double-double arithmetic functionality

orx-v

Traits to unify all vectors!

knossos

generating and rendering mazes

scru128

Sortable, Clock and Random number-based Unique identifier

glass_pumpkin

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

clone_dyn

Derive to clone dyn structures

murmurhash32

murmurhash32_2

accurate

(more or less) accurate floating point algorithms

smawk

Functions for finding row-minima in a totally monotone matrix

nlopt

Wrapper for the nlopt library

dive-deco

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

s2-tilejson

Backwards compatible JSON format for describing s2 map tilesets

cggmp21

TSS ECDSA implementation based on CGGMP21 paper

highs

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

kube_quantity

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

caches

popular caches (support no_std)

graph

high-performant graph algorithms

z3

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

dmp

A high-performance library in that manipulates plain text

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

genetic_algorithm

A genetic algorithm implementation

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

secret-santa-rs

Generator for who buys for who in a secret santa

oxyroot

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

ndarray-rand

Constructors for randomized arrays. rand integration for ndarray.

muldiv

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

version-ranges

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

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

incremental

computations, based on Jane Street's incremental

general-sam

A general suffix automaton implementation in Rust

scnr

Scanner/Lexer with regex patterns and multiple modes

petal-neighbors

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

trackball

Virtual Trackball Orbiting via the Exponential Map

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

rollgrid

pseudo-infinite open worlds

rectangle-pack

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

rs-stats

Statistics library in rust

tantivy-fst

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

soa-rs

A Vec-like structure-of-arrays container

arpfloat

Arbitrary-precision floating point library

xgraph

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

rustfst-ffi

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

dypdl-heuristic-search

Heuristic search solvers for Dynamic Programming Description Language (DyPDL)

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

rucrf

Conditional Random Fields implemented in pure Rust

num_convert

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

cubecl-reduce

CubeCL Reduce Algorithms

metatensor

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

probminhash

Minhash algorithms for weighted Jaccard index

toodee

A lightweight 2D wrapper around a Vec

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'

diffusionx

random number/stochastic process simulation with high performance

quad-rand

Pseudo random implementation with core atomics

simplehash

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

mini-mcmc

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

feos-campd

Computer-aided molecular and process design using the FeOs framework

adler32

Minimal Adler32 implementation for Rust

nanoid

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

fast_hilbert

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

timsort

modified MergeSort used in Python and Java

bit-matrix

bit matrices and vectors

atomic-traits

The traits for generic atomic operations

scirs2-optimize

Optimization module for SciRS2

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

chronologic

Time constraint reasoning (scheduling...)

ceres-solver

Safe Rust bindings for the Ceres Solver

random_color

generating random attractive colors

graaf

Work with directed graphs

ta

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

oxirush-nas

5G NAS Message encoder/decoder library

bridgetree

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

rand_simple

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

pyinrs

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

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

xgb

Machine learning using XGBoost

error_tools

Basic exceptions handling mechanism

ids_service

that allows to generate unique Ids

feruca

Unicode Collation Algorithm

i_triangle

Polygon Triangulation Library: Efficient Delaunay Triangulation for Complex Shapes

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

geometry-predicates

port of robust geometric predicates

coord2d

rust lib for coordinate in 2d system

ddo

generic and efficient framework for MDD-based optimization

syntree_layout

visualize trees from the 'syntree' crate

color_space

converting between color spaces and comparing colors

i_shape

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

annembed

dimension reduction à la Umap

bit_gossip

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

cdshealpix

HEALPix tesselation

panfix

parsing: linear time parsing of multifix operators

wcs

FITS World Coordinate System (WCS)

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

easyfft

providing an easy FFT API for arrays and slices

unty

Explicitly types your generics

broccoli

broadphase collision detection algorithms

here_be_dragons

Map generator for games

pyimports

Parse and analyze the imports within a python package

rdst

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

algos

A collection of algorithms in Rust

xiangting

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

smolprng

A Small and Extensible PRNG written in Rust

rithm

Arbitrary precision arithmetic

vrp-core

A core algorithms to solve a Vehicle Routing Problem

fast_poisson

Bridson's algorithm for fast Poisson disk sampling

linfa-linalg

Pure-Rust implementation of linear algebra routines for ndarray

zspell

Native Rust library for spellchecking

kd-tree

k-dimensional tree

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

count-min-sketch

Count-min-sketch implementation

shor

Shor's factoring algorithm written in rust

cast

Ergonomic, checked cast functions for primitive types

mpchash

Multi-probe consistent hashing algorithm implementation

xxhrs

Safe XXHash and XXH3 bindings

polygons

Fast points-in-polygon test and distances to polygons

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.

dlx-rs

dancing links in Rust

volute

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

bpe-openai

Prebuilt fast byte-pair encoders for OpenAI

stringmetrics

approximate string matching

clingo

Rust idiomatic bindings to the clingo library

rs-wordle-solver

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

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

crc32-v2

A port of the CRC-32 algorithm to Rust

layer-proc-gen

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

keyforge95

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

sif-embedding

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

simsearch

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

pmcore

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

edfsm

Event Driven Finite State Machine library

pm-remez

Parks-McClellan Remez FIR design algorithm

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

clipper2

A polygon Clipping and Offsetting library for Rust

rust_intervals

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

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

rocm-rs

Rust bindings for AMD ROCm libraries

graph-algorithms-rs

A collection of graph algorithms

nu_plugin_hashes

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

nabla-ml

A numpy-like library for Rust

wavefc

A home-grown implementation of the Wave Function Collapse algorithm

importunate

Methods for returning random elements from an iterator

graphrs

package for the creation, manipulation and analysis of graphs

sfcgal

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

sefar

evolutionary optimization algorithms

docker-image

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

rust-spice

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

fastatomstruct

A Python package for the analysis of atomic structures and dynamics

jismesh

handling and converting JIS X0410 area mesh codes

brique-rs

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

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'

cmsketch

A count min sketch implementation in Rust

timberio/file-source

A high-performance observability data pipeline

moongraph

Schedules and runs DAGs accessing shared resources. 🌙

numext-fixed-uint

Fixed-size uint types

t1ha

T1AH (Fast Positive Hash) hash function

density-rs

Superfast compression library

tolerance

Math representation of the physically needed permissible deviation of measures

permutation

Small utility for creating, manipulating, and applying permutations

ognlib

Some code that is written to practice Rust

dilate

A compact, high performance integer dilation library for Rust

liba

An algorithm library based on C/C++

opendp

differential privacy algorithms for the statistical analysis of sensitive private data

jawe-cuvs-iii

RAPIDS vector search library

lp-solvers

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

arbi

Arbitrary Precision Integer

sonic-api

API for formally-verifiable distributed contracts

jopemachine-raft

language implementation of Raft algorithm

hyper_byte

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

libsufr

Parallel Construction of Suffix Arrays in Rust

pharmsol

solving analytic and ode-defined pharmacometric models

hashinator

identify hashes blazingly fast

fugue

A binary analysis framework written in Rust

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

uniset

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

lutz

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

lazyrand

generating random numbers easily

geos-sys

GEOS C API bindings

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

localsearch

Local Search based Metaheuristics

noise-functions

A collection of fast and lightweight noise functions

stash

An amortized O(1) table for cases where you don’t need to choose the keys and want something faster than a HashTable

probability

The package provides a probability-theory toolbox

simdutf

Unicode validation and transcoding at billions of characters per second

hronn

An experimental CNC toolpath generator

geomorph

conversion between different coordinate systems

easer

Tiny library imlementing Robert Penner's easing functions

quine-mccluskey

Boolean function minimizer based on Quine–McCluskey algorithm

tetengo_lattice

Viterbi search and A* algorithm implementation

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

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

cmaes

CMA-ES optimization algorithm

blosc

Rust bindings to the C-BLOSC compression library

hud-slice-by-8

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

libecvrf

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

abd-clam

Clustering, Learning and Approximation with Manifolds

turborand

Fast random number generators

f3l_segmentation

3D Point Cloud Library

b10

Lossless handling of decimal numbers at maximum performance

extendhash

Rust Hash Extender

markov_namegen

Random text generators based on Markov models

boomphf

Scalable and Efficient Minimal Perfect Hash Functions

zeros

treerder

Trie ordering for type implementing Orderable