Lib.rs

rand

Random number generators and other randomness functionality

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

ahash

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

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

rand_xoshiro

Xoshiro, xoroshiro and splitmix64 random number generators

stacker

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

crc32fast

Fast, SIMD-accelerated CRC32 (IEEE) checksum computation

ff

building and interfacing with finite fields

ulid

a Universally Unique Lexicographically Sortable Identifier implementation

realfft

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

bytecount

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

rstar

An R*-tree spatial index

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.

noise

Procedural noise generation library

ndarray-linalg

Linear algebra package for rust-ndarray using LAPACK

dissimilar

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

fnv

Fowler–Noll–Vo hash function

highway

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

rand_distr

Sampling from random number distributions

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

oorandom

A tiny, robust PRNG implementation

passwords

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

stringprep

algorithm

crc32c

Safe implementation for hardware accelerated CRC32C instructions with software fallback

wildmatch

string matching with single- and multi-character wildcard operator

foldhash

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

microfft

Embedded-friendly Fast Fourier Transforms

gcd

Calculate the greatest common divisor

murmur3

hash

topological-sort

Performs topological sorting

i_overlay

Boolean Operations for 2D Polygons: Supports intersection, union, difference, xor, and self-intersections for all polygon varieties

differential-dataflow

An incremental data-parallel dataflow platform

rand_hc

HC128 random number generator

bounded-integer

Bounded integers

salsa

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

argminmax

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

gix-revwalk

providing utilities for walking the revision graph

treediff

Find the difference between arbitrary data structures

resolvo

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

edit-distance

Levenshtein edit distance between strings, a measure for similarity

rand_regex

Generates random strings and byte strings matching a regex

medians

Median, Statistical Measures, Mathematics, Statistics

special

The package provides special functions

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

seahash

A blazingly fast, portable hash function with proven statistical guarantees

rustfst

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

float_eq

Compare IEEE floating point primitives, structs and collections for equality

rapidhash

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

halfbrown

Multi backend HashMap for higher performance on different key space sizes

earcutr

port of MapBox's earcut triangulation code to Rust language

vek

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

linregress

ordinary least squared linear regression with some basic statistics

simd-adler32

A SIMD-accelerated Adler-32 hash algorithm implementation

memx

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

alphanumeric-sort

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

rand_jitter

Random number generator based on timing jitter

levenshtein

algorithm

GSL

binding for the GSL (the GNU scientific library)

metrohash

high quality, high performance hash algorithm

adler

clean-room implementation of the Adler-32 checksum

arrow-ord

Ordering kernels for arrow arrays

fastcdc

(content defined chunking) in pure Rust

k

kinematics

wildcard

matching

rand_mt

Reference Mersenne Twister random number generators

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…

reed-solomon-simd

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

sketches-ddsketch

A direct port of the Golang DDSketch implementation

hexf-parse

Parses hexadecimal floats (see also hexf)

jubjub

elliptic curve group

merkle_hash

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

bytebuffer

networking and binary protocols

bm25

BM25 embedder, scorer, and search engine

simplerand

fast random number generator

permutation

Small utility for creating, manipulating, and applying permutations

rust-stemmers

some popular snowball stemming algorithms

fractional_index

fractional indexing

tree_iterators_rs

built to provide you with the iterators to easily work with tree data structures in Rust

geo-clipper

Boolean operations on polygons

partial_sort

provide a Rust version std::partial_sort

mapproj

(a part of) map projections defined in the FITS World Coordinate System (WCS)

flo_curves

manipulating Bezier curves

interp

Matlab's interp1 function

range-set

Smallvec-backed containers of sorted integer ranges

hime_redist

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

hnsw_rs

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

timely

A low-latency data-parallel dataflow system in Rust

raft

language implementation of Raft algorithm

lattices

Lattice data types for simplifying distributed state by providing associativity, commutativity, and idempotence

nanorand

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

dusk-bls12_381

Fork of the implementation of the BLS12-381 pairing-friendly elliptic curve construction with some extra tooling needed by the Dusk team

ndarray-slice

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

kand

Pure Rust technical analysis library inspired by TA-Lib

optirustic

A multi-objective optimisation framework for Rust

tenthash

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

counter

package to count generic iterables

integer-sqrt

integer square root algorithm for primitive rust types

keyword_extraction

Collection of algorithms for keyword extraction from text

boyer-moore-magiclen

fast string search algorithm implemented in Rust

levenberg-marquardt

algorithm built on top of nalgebra

pubgrub

version solving algorithm

smawk

Functions for finding row-minima in a totally monotone matrix

cubecl-reduce

CubeCL Reduce Algorithms

linestring

line string toolbox

chalk-engine

Core trait engine from Chalk project

qr2term

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

knossos

generating and rendering mazes

i_float

This fixed float math library provides an efficient and deterministic solution for arithmetic and geometric operations

mt19937

A translation of the MT19937 Mersenne Twister rng algorithm to Rust

naive_opt

The optimized naive string-search algorithm

radsort

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

diff-match-patch-rs

The fastest implementation of Myer's diff algorithm to perform the operations required for synchronizing plain text

wyrand

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

quantiles

a collection of approximate quantile algorithms

cam-geom

Geometric models of cameras for photogrammetry

russcip

Rust interface for SCIP

fast_paths

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

dypdl

Libarary for Dynamic Programming Description Language (DyPDL)

murmurhash32

murmurhash32_2

twofloat

Double-double arithmetic functionality

setsum

order-agnostic checksum

cggmp21

TSS ECDSA implementation based on CGGMP21 paper

scru128

Sortable, Clock and Random number-based Unique identifier

accurate

(more or less) accurate floating point algorithms

ndarray-rand

Constructors for randomized arrays. rand integration for ndarray.

linfa-linalg

Pure-Rust implementation of linear algebra routines for ndarray

transpose

transposing multi-dimensional data

genetic_algorithms

solving genetic algorithm problems

muldiv

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

tailcall

Safe, zero-cost tail recursion

dusk-poseidon

Poseidon hash algorithm over the Bls12-381 Scalar field

error_tools

Basic exceptions handling mechanism

highs

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

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.

cardinality-estimator

estimating the cardinality of distinct elements in a stream or dataset

aoc-parse

A little library for parsing your Advent of Code puzzle input

osqp

(Operator Splitting Quadratic Program) solver

robust

adaptive floating-point predicates for computational geometry

kube_quantity

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

glissade

that provides various utilities for animations and transitions

lilt

running interruptable, transition based animations as a function of time

xgraph

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

bevy_knossos

generating and rendering mazes

usearch

Smaller & Faster Single-File Vector Search Engine from Unum

orx-v

Traits to unify all vectors!

hierarchical_hash_wheel_timer

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

overlook

An animated visualiser of different maze generation and solving algorithms, running the terminal

petal-neighbors

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

incremental

computations, based on Jane Street's incremental

creusot-contracts

contracts and logic helpers for Creusot

scnr

Scanner/Lexer with regex patterns and multiple modes

arcos-kdl

ARCOS-Lab Kinematics and Dynamics Library

general-sam

A general suffix automaton implementation in Rust

probminhash

Minhash algorithms for weighted Jaccard index

rustfst-ffi

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

mergable

user-friendly and efficient CRDTs

auto-palette

🎨 A Rust library that extracts prominent color palettes from images automatically

rectangle-pack

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

arpfloat

Arbitrary-precision floating point library

num_convert

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

cdshealpix

HEALPix tesselation

dbsp

Continuous streaming analytics engine

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

udigest

Unambiguously digest structured data

fletcher

A dependency free implementation of the Fletcher's checksum algorithm

rex-sm

Hierarchical state machine

advent-of-code

Solutions to Advent of Code

num-order

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

kdtree

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

cryptocol

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

vrp-cli

A command line interface for VRP solver

timsort

modified MergeSort used in Python and Java

s2-tilejson

Backwards compatible JSON format for describing s2 map tilesets

mini-mcmc

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

ta

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

itermore

🤸‍♀️ More iterator adaptors

satkit

Satellite Toolkit

interpn

N-dimensional interpolation/extrapolation methods, no-std and no-alloc compatible

dilate

A compact, high performance integer dilation library for Rust

diffusionx

random number/stochastic process simulation with high performance

quad-rand

Pseudo random implementation with core atomics

rucrf

Conditional Random Fields implemented in pure Rust

feruca

Unicode Collation Algorithm

feos-campd

Computer-aided molecular and process design using the FeOs framework

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

toktrie

LLM Token Trie library

lt-fm-index

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

rust-spice

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

meos

Rust bindings for MEOS C API

random_color

generating random attractive colors

kd-tree

k-dimensional tree

rollgrid

pseudo-infinite open worlds

byteyarn

hyper-compact strings

random_word

Efficient functions for generating random words in many languages

advancedresearch-toy_model_of_physical_seshatic_identity

toy model for physical Seshatic identity that satisfies the holographic principle

graaf

Work with directed graphs

rsc_osrm

rust wrapper for osrm, folk from TehGoat/rs_osrm

rhai-sci

Scientific computing in the Rhai scripting language

opendp

differential privacy algorithms for the statistical analysis of sensitive private data

color_space

converting between color spaces and comparing colors

stcalc

Stack calculator

rithm

Arbitrary precision arithmetic

swipl

A high-level library for building SWI-Prolog extensions and embedding SWI-Prolog in rust applications

easyfft

providing an easy FFT API for arrays and slices

rdst

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

hyperloglogplus

HyperLogLog implementations

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.

geometry-predicates

port of robust geometric predicates

urandom

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

extendhash

Rust Hash Extender

dogear

merging bookmark trees

rand_aes

AES based pseudo-random number generator

wcs

FITS World Coordinate System (WCS)

radiate

genetic algorithms and artificial evolution

here_be_dragons

Map generator for games

smolprng

A Small and Extensible PRNG written in Rust

dypdl-heuristic-search

Heuristic search solvers for Dynamic Programming Description Language (DyPDL)

clingo

Rust idiomatic bindings to the clingo library

broccoli

broadphase collision detection algorithms

graph_process_manager_loggers

Generic loggers for graph_process_manager_core

bevy_lookup_curve

Editable lookup curve for Bevy

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

brique-rs

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

relative-duration

Duration with negative capabilities

mpchash

Multi-probe consistent hashing algorithm implementation

four-bar

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

syntree_layout

visualize trees from the 'syntree' crate

algos

A collection of algorithms in Rust

tantivy-fst

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

simsearch

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

od_opencv

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

ids_service

that allows to generate unique Ids

xiangting

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

xxhrs

Safe XXHash and XXH3 bindings

count-min-sketch

Count-min-sketch implementation

loga

Combined logging and error handling

english-to-cron

converts natural language into cron expressions

bit-iter

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

iter_tools

Collection of general purpose tools to iterate. Currently it simply reexports itertools.

rust_intervals

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

spareval

A SPARQL evaluator

ddo

generic and efficient framework for MDD-based optimization

fauxgen

write your own generators in stable rust

nabla-ml

A numpy-like library for Rust

sequence-generator-rust

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

acap

As Close As Possible — nearest neighbor search in Rust

polygons

Fast points-in-polygon test and distances to polygons

vecmath

type agnostic library for vector math designed for reexporting

stringmetrics

approximate string matching

crc32-v2

A port of the CRC-32 algorithm to Rust

pyinrs

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

deaf

parsing and modifying ELF binaries

pokemon-rs

getting Pokémon names

tokio-util-codec-compose

Building blocks for composing tokio-util codecs

pracstro

A simplistic library for astronomy

numerical-multiset

An ordered multiset of machine numbers

dims

Unit-Aware Types Library

to_shmem

Trait to write to a contiguous chunk of shared memory

hyperlight-host

A lightweight Virtual Machine Manager that can be hosted in an application to safely run untrusted or code within a VM partition with very low latency and overhead

bit_gossip

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

varint-rs

A small, zero dependency varint implementation in Rust

logru

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

task-local-extensions

Task-local container for arbitrary data

randevu

The official Rust implementation of the RANDEVU algorithm

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

wavefc

A home-grown implementation of the Wave Function Collapse algorithm

time_series_generator

Generate various timeseries of given length, some randomly sampled

importunate

Methods for returning random elements from an iterator

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'

bevy_state_plugin_generator

A build-dependency that generates a Bevy State Plugin from a simple state definition

sfcgal

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

statig

Hierarchical state machines for designing event-driven systems

timberio/file-source

A high-performance observability data pipeline

clipper2

A polygon Clipping and Offsetting library for Rust

zeros

numext-fixed-uint

Fixed-size uint types

uniset

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

probability

The package provides a probability-theory toolbox

oxidd-reorder

Reordering algorithms for OxiDD

t1ha

T1AH (Fast Positive Hash) hash function

jopemachine-raft

language implementation of Raft algorithm

times

Timing Benchmark, Repeated Runs, with Statistics

dotlr

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

hud-slice-by-8

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

sonic-api

API for formally-verifiable distributed contracts

noise-functions

A collection of fast and lightweight noise functions

fastnoise-lite

FastNoise Lite is an extremely portable open source noise generation library with a large selection of noise algorithms

liba

An algorithm library based on C/C++

compile_time_sort

Sort arrays and slices of primitives in const contexts

clipline

Efficient rasterization of line segments with pixel-perfect clipping

pm-remez

Parks-McClellan Remez FIR design algorithm

polars-ops

More operations on Polars data structures

lsmtk

log-structured-merge-graph

ipl3checksum

calculate the IPL3 checksum for N64 ROMs

sefar

evolutionary optimization algorithms

rand_core

Core random number generator traits and tools for implementation

kendalls

Kendall's tau rank correlation

lutz

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

lazy_async_promise

Primitives for lazily getting data from futures with tokio for immediate mode guis

merkle-cbt

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

is_sorted

Iterator sorted?

volute

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

gvox-rs

Voxel file format parser

easer

Tiny library imlementing Robert Penner's easing functions

h3o-zip

A compression scheme tailored for H3 cell indexes

rake

Rapid Automatic Keyword Extraction (RAKE) algorithm

datas

data structures and algorithms and data analisys

shared-buffer

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

polynomial

manipulating polynomials

wtools

Collection of general purpose tools for solving problems. Fundamentally extend the language without spoiling, so may be used solely or in conjunction with another module of such kind.

movavg

Generic Moving Average calculation

sif-embedding

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

bpe-openai

Prebuilt fast byte-pair encoders for OpenAI

array__ops

A selection of useful array operations

mutcursor

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

muchin

Support for composing large, interacting, complicated state machines

sobol_burley

A seedable Owen-scrambled Sobol sequence

natord

Natural ordering for Rust

quine-mccluskey

Boolean function minimizer based on Quine–McCluskey algorithm

out

fast min and max functionality for collections

pingora-limits

rate limiting and event frequency estimation

is-tree

Everything is a tree

xgadget

Fast, parallel, cross-variant ROP/JOP gadget search for x86/x64 binaries

seastar

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

flo_binding

Declarative binding library for Rust

graph-algorithms-rs

A collection of graph algorithms

rust_abf

reading data from Axon Binary Format (ABF) files

tolerance

Math representation of the physically needed permissible deviation of measures

graphina

A graph data science library for Rust

downstream

efficient, constant-space implementations of stream curation algorithms

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…

libmacchina

that can fetch all sorts of system information

pasture-algorithms

Point cloud algorithms for pasture

crunch

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

unarray

working with uninitialized arrays

recursive

Easy recursion without stack overflows

rand_simple

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

tfon

Bitmap font parsing / conversion

kewb

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

singlevec

Vec-like container optimized for storing only a single item

simple_hll

HyperLogLog implementation in rust

coord2d