Lib.rs

rand

Random number generators and other randomness functionality

fastrand

fast random number generator

strsim

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

crc

support of various standards

twox-hash

XXHash and XXH3 algorithms

rustc-hash

A speedy, non-cryptographic hashing algorithm used by rustc

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

ahash

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

fnv

Fowler–Noll–Vo hash function

stacker

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

noise

Procedural noise generation library

ulid

a Universally Unique Lexicographically Sortable Identifier implementation

dissimilar

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

rstar

An R*-tree spatial index

siphasher

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

bytecount

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

ff

building and interfacing with finite fields

wildmatch

string matching with single- and multi-character wildcard operator

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.

kiddo

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

oorandom

A tiny, robust PRNG implementation

pathfinding

flow, and graph algorithms

crc32c

Safe implementation for hardware accelerated CRC32C instructions with software fallback

highway

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

passwords

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

stringprep

algorithm

oci-spec

Open Container Initiative Specifictions in Rust

realfft

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

uint

Large fixed-size integer arithmetic

strength_reduce

Faster integer division and modulus operations

robust

adaptive floating-point predicates for computational geometry

yada

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

gcd

Calculate the greatest common divisor

topological-sort

Performs topological sorting

sgp4

A pure Rust implementation of the SGP4 algorithm for satellite propagation

edit-distance

Levenshtein edit distance between strings, a measure for similarity

task-local-extensions

Task-local container for arbitrary data

rand_jitter

Random number generator based on timing jitter

ndarray-linalg

Linear algebra package for rust-ndarray using LAPACK

seahash

A blazingly fast, portable hash function with proven statistical guarantees

zipf

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

gix-filter

gitoxide project implementing git filters

rustfst

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

murmur3

hash

levenshtein

algorithm

nanorand

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

sketches-ddsketch

A direct port of the Golang DDSketch implementation

microfft

Embedded-friendly Fast Fourier Transforms

buffer-redux

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

medians

Median, Statistical Measures, Mathematics, Statistics

treediff

Find the difference between arbitrary data structures

nucleo

plug and play high performance fuzzy matcher

special

The package provides special functions

argminmax

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

reed-solomon-novelpoly

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

fastcdc

(content defined chunking) in pure Rust

slice-group-by

Iterators over groups in slices and strs

rand_xoshiro

Xoshiro, xoroshiro and splitmix64 random number generators

streaming-iterator

Streaming iterators

resolvo

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

textdistance

Lots of algorithms to compare how similar two sequences are

simd-adler32

A SIMD-accelerated Adler-32 hash algorithm implementation

halfbrown

Multi backend HashMap for higher performance on different key space sizes

GSL

binding for the GSL (the GNU scientific library)

arrow-cast

Cast kernel and utilities for Apache Arrow

z3

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

graph

high-performant graph algorithms

earcutr

port of MapBox's earcut triangulation code to Rust language

memx

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

genetic_algorithm

A genetic algorithm implementation

rust-stemmers

some popular snowball stemming algorithms

muldiv

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

vek

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

linfa-linalg

Pure-Rust implementation of linear algebra routines for ndarray

moc

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

adler

clean-room implementation of the Adler-32 checksum

hnsw_rs

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

arma-rs

Arma 3 Extensions in Rust

chalk-recursive

Recursive solver for the Chalk project

hime_redist

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

transpose

transposing multi-dimensional data

fast_paths

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

daachorse

Double-Array Aho-Corasick

hexf-parse

Parses hexadecimal floats (see also hexf)

mergable

user-friendly and efficient CRDTs

ddo

generic and efficient framework for MDD-based optimization

raft

language implementation of Raft algorithm

arrow-ord

Ordering kernels for arrow arrays

ndarray-rand

Constructors for randomized arrays. rand integration for ndarray.

kd-tree

k-dimensional tree

varpro

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

biodiff

Compare binary files using sequence alignment

crossterm_winapi

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

rand_mt

Reference Mersenne Twister random number generators

rand_regex

Generates random strings and byte strings matching a regex

reblessive

A small runtime for running deeply nested recursive functions

timsort

modified MergeSort used in Python and Java

shapefile

Read & Write shapefiles in Rust

fractional_index

fractional indexing

smawk

Functions for finding row-minima in a totally monotone matrix

glass_pumpkin

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

ndarray-slice

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

merkle_hash

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

easy-smt

Easily interact with an smt solver as a subprocess

genetic_algorithms

solving genetic algorithm problems

k

kinematics

tantivy-fst

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

tailcall

Safe, zero-cost tail recursion

num_convert

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

incremental

computations, based on Jane Street's incremental

chalk-engine

Core trait engine from Chalk project

boyer-moore-magiclen

fast string search algorithm implemented in Rust

reactive_graph

A fine-grained reactive graph for building user interfaces

dusk-poseidon

Poseidon hash algorithm over the Bls12-381 Scalar field

blurhash

A pure Rust implementation of blurhash

keyword_extraction

Collection of algorithms for keyword extraction from text

unit-conversions

Various units of measurement conversions

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

libcprover_rust

Rust API for CBMC and assorted CProver tools

jubjub

elliptic curve group

orx-priority-queue

Priority queue traits and high performance d-ary heap implementations

dec

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

idsp

DSP algorithms for embedded, mostly integer math

naive_opt

The optimized naive string-search algorithm

levenberg-marquardt

algorithm built on top of nalgebra

dive-deco

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

gxhash

non-cryptographic algorithm

t1ha

T1AH (Fast Positive Hash) hash function

rs-wordle-solver

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

distances

Fast and generic distance functions for high-dimensional data

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…

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.

radsort

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

rand_chacha

ChaCha random number generator

byteyarn

hyper-compact strings

alphanumeric-sort

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

rand_simple

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

ids_service

that allows to generate unique Ids

cdshealpix

HEALPix tesselation

accurate

(more or less) accurate floating point algorithms

probminhash

Minhash algorithms for weighted Jaccard index

quantiles

a collection of approximate quantile algorithms

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.

census

Keeps an inventory of living objects

scru128

Sortable, Clock and Random number-based Unique identifier

lt-fm-index

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

cam-geom

Geometric models of cameras for photogrammetry

graaf

Work with directed graphs

highs

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

russcip

Rust interface for SCIP

extendhash

Rust Hash Extender

fast_polynomial

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

rust-spice

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

cap-rand

Capability-based random number generators

murmurhash32

murmurhash32_2

advent-of-code

Solutions to Advent of Code

turborand

Fast random number generators

arpfloat

Arbitrary-precision floating point library

av-metrics

A collection of algorithms for measuring audio/video metrics

ran

fast random numbers generation

diff-match-patch-rs

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

starlight

experimental HDL and optimizer for DAGs of lookup tables

fuzzy-muff

Fuzzy Matching Library

crc64fast

SIMD accelerated CRC64 calculation

petal-neighbors

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

polylog

polylogarithms

gcra

A basic implementation of GCRA algorithm for rate limiting

rurel

Flexible, reusable reinforcement learning (Q learning) implementation

hmac-sha1

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

dbsp

Continuous streaming analytics engine

clone_dyn

Derive to clone dyn structures

itermore

🤸‍♀️ More iterator adaptors

tinymt

64/32 - a lightweight variant of Mersenne Twister PRNG

sfcgal

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

macro-machines

State machine macros with logging and graphviz DOT file generation

rustfst-ffi

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

triple_accel

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

broccoli

broadphase collision detection algorithms

adler32

Minimal Adler32 implementation for Rust

float_next_after

A trait for native rust f64/f32 nextafter

rex-sm

Hierarchical state machine

rectangle-pack

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

nozomi

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

interval_adapter

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

differential-dataflow

An incremental data-parallel dataflow platform

dilate

A compact, high performance integer dilation library for Rust

easyfft

providing an easy FFT API for arrays and slices

adler2

clean-room implementation of the Adler-32 checksum

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.

mpchash

Multi-probe consistent hashing algorithm implementation

scnr

Scanner/Lexer with regex patterns and multiple modes

optirustic

A multi-objective optimisation framework for Rust

clingo

Rust idiomatic bindings to the clingo library

bevy_math

math functionality for Bevy Engine

vrp-core

A core algorithms to solve a Vehicle Routing Problem

opensimplex2

Port of OpenSimplex2

kdtree

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

d3_geo_voronoi_rs

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

adskalman

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

cubecl

Multi-platform high-performance compute language extension for Rust

smolprng

A Small and Extensible PRNG written in Rust

random_word

Efficient functions for generating random words in many languages

iroh-blobs

blob and collection transfer support for iroh

probability

The package provides a probability-theory toolbox

rsc_osrm

rust wrapper for osrm, folk from TehGoat/rs_osrm

mesh_to_sdf

Mesh to signed distance field (SDF) converter

fletcher

A dependency free implementation of the Fletcher's checksum algorithm

sequence-generator-rust

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

cubecl-linalg

CubeCL Linear Algebra Library

bit_gossip

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

metaheuristics-nature

A collection of nature-inspired metaheuristic algorithms

mhgl

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

cryptocol

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

romu

A pseudo random number generator using the Romu algorithm

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.

volute

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

xxhrs

Safe XXHash and XXH3 bindings

atomic-traits

The traits for generic atomic operations

pasture-algorithms

Point cloud algorithms for pasture

tiny_sort

Binary-size optimized stable and unstable sorts

general-sam

A general suffix automaton implementation in Rust

quad-rand

Pseudo random implementation with std atomics

color_space

converting between color spaces and comparing colors

wyrand

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

nlopt

Wrapper for the nlopt library

cyclic-poly-23

A rolling, decomposable hash algorithm

dogear

merging bookmark trees

extsort

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

simsearch

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

axgeom

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

uniset

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

swift_vec

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

scalarff

A minimal, opinionated, library for working with scalar finite fields

tau-engine

A document tagging library

vortex-array

Vortex in memory columnar data format

zeros

bm25

BM25 embedder and search engine

hyperloglogplus

HyperLogLog implementations

rdst

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

dotlr

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

yara-x-parser

A parsing library for YARA rules

geo-clipper

Boolean operations on polygons

gix-revwalk

providing utilities for walking the revision graph

ckey

consistent hash key library

autour_core

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

hypertwobits

cardinality estimation algorithm

iron-shapes

Basic data types and routines for computational geometry focused on VLSI chip design

pharmsol

solving analytic and ode-defined pharmacometric models

strs_tools

Tools to manipulate strings

meos

Rust bindings for MEOS C API

crunch

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

localsearch

Local Search based Metaheuristics

pyin

pYIN pitch detection algorithm written in Rust

controlled_astar

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

liba

An algorithm library based on C/C++

timberio/file-source

A high-performance observability data pipeline

rust-sugiyama

Sugiyama's algorithm to calculate coordinates of a directed graph

kewb

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

startin

A Delaunay triangulator for terrains

udigest

Unambiguously digest structured data

rollgrid

pseudo-infinite open worlds

poi

A pragmatic point-free theorem prover assistant

convolve2d

Easy and extensible pure rust image convolutions

wyhash

fast portable non-cryptographic hashing algorithm and random number generator

sulid

unique ID generation algorithm that combines the benefits of ULID and Snowflake

earclip

Triangle mesh designed to be fast, efficient, and sphere capable

four-bar

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

kendalls

Kendall's tau rank correlation

hud-slice-by-8

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

bevy_lookup_curve

Editable lookup curve for Bevy

grid_pathfinding

Pathfinding using JPS and connected components on a grid

ognlib

Some code that is written to practice Rust

fastlem

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

rufl

A powerful util function library for rust

times

Timing Benchmark, Repeated Runs, with Statistics

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'

kociemba

solving the 3x3 Rubik's cube with Kociemba's two phase algorithm

feruca

Unicode Collation Algorithm

louvre

A Robust Triangulation Algorigthm

counting_sort

Counting sort implementation for Iterators

natord

Natural ordering 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

dynalgo

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

xentrace-parser

A XenTrace files parser with a study purpose

randevu

The official Rust implementation of the RANDEVU algorithm

opis

rational number and matrix arithmetic

shared-buffer

An abstraction over buffers backed by memory-mapped files or bytes in memory

cvmcount

CVM algorithm to quickly estimate the number of distinct elements in a stream

arrow-string

String kernels for arrow arrays

rhai-sci

Scientific computing in the Rhai scripting language

graph_process_manager_loggers

Generic loggers for graph_process_manager_core

sobol_burley

A seedable Owen-scrambled Sobol sequence

pm-remez

Parks-McClellan Remez FIR design algorithm

rands

Random number generators and other randomness functionality

linestring

line string toolbox

fuzzy_prefix_search

Fuzzy search for prefix matches

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…

edfsm

Event Driven Finite State Machine library

flo_binding

Declarative binding library for Rust

vecmath

type agnostic library for vector math designed for reexporting

sif-embedding

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

mt19937

A translation of the MT19937 Mersenne Twister rng algorithm to Rust

easer

Tiny library imlementing Robert Penner's easing functions

ahrs

port of Madgwick's AHRS algorithm

breakout

detection for Rust

random

The package provides sources of randomness

flat_spatial

Flat spatial partitionning algorithms and data structures

bool_vec

A crates that exposes a vector called BoolVec which allows you to store a boolean in a single bit

kube_quantity

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

interp

Matlab's interp1 function

easing-function

easing functions for animation tweening

i_triangle

Polygon Triangulation Library: Efficient Delaunay Triangulation for Complex Shapes

ar-reshaper

A no-std crate to reconstruct Arabic, turkish and persian sentences to be used in applications that don't support Arabic script

libmf

Large-scale sparse matrix factorization for Rust

augrim

consensus algorithms implemented in Rust

rugraph

undirected, directed and multidirected graph library

random-nickname2

用于Rust的随机用户昵称生成器

bies

Helpers for dealing with BIES vectors with text segmentation applications

board-game

A board game abstraction and generic utilities around it

rithm

Arbitrary precision arithmetic

stringmetrics

approximate string matching

syntree_layout

visualize trees from the 'syntree' crate

ext-sort

rust external sort algorithm implementation

suggest

A minimal library to provide similar name suggestions like "Did you mean?"

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.

modular-decomposition

computing the modular decomposition of a graph

stupid_utils

that provides some simple and maybe stupid or useful tools

weighted_rand

A weighted random sampling crate using Walker's Alias Method

partial_sort

version of std::partial_sort

extsort-iter

external sorting for all types for all iterators

clipper2

A polygon Clipping and Offsetting library for Rust

voracious_radix_sort

State of the art radix sort algorithms. Single thread and multi thread versions.

kak-tabs

kakoune tabs

lilt

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

ibn_battuta

Solving the Travelling Salesman Problem (TSP)

tifloats

Speedy, accurate emulation of TI-Floats

rmqtt-raft

raft framework, for regular people

round_robin

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

cnccoder

generating gcode operations targeted for GRBL controled cnc machines, and also generates camotics projects for simulation

fuzzyhash

Pure Rust fuzzy hash implementation

rake

Rapid Automatic Keyword Extraction (RAKE) algorithm

bit-cursor

A cursor that supports bit-level reads and writes

futf

Handling fragments of UTF-8

fenex

parsing and handling FEN and algebraic chess notations

small_len

A small library for storing the length in the smallest internal type

async-rate-limiter

Implements a token bucket algorithm that can be used to limit API access frequency. Written in pure Rust.

decmathlib-rs

Port of the Intel Decimal Floating-Point Math Library decimal128 type to Rust

noiselib

procedural 1D, 2D, 3D and 4D noise and fractal functions

regex-filtered

Efficiently check an input against a large number of patterns

everything-sdk

An ergonomic Everything(voidtools) SDK wrapper in Rust. (Supports async and raw sdk functions)

elipdotter

Embeddable full text search engine

is_sorted

Iterator sorted?