Lib.rs

rand

Random number generators and other randomness functionality

crc

support of various standards

ahash

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

strsim

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

fastrand

fast random number generator

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…

rustc-hash

A speedy, non-cryptographic hashing algorithm used by rustc

rustfft

High-performance FFT library written in pure Rust

xxhash-rust

xxhash

md5

The package provides the MD5 hash function

realfft

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

sprs

A sparse matrix library

twox-hash

XXHash and XXH3 algorithms

streaming-iterator

Streaming iterators

ulid

a Universally Unique Lexicographically Sortable Identifier implementation

scroll

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

stacker

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

rstar

An R*-tree spatial index

rapidhash

An extremely fast, high quality, platform-independent hashing algorithm

kiddo

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

pathfinding

flow, and graph algorithms

crc32c

Safe implementation for hardware accelerated CRC32C instructions with software fallback

bytecount

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

wildmatch

string matching with single- and multi-character wildcard operator

ff

building and interfacing with finite fields

siphasher

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

blstrs

High performance implementation of BLS12 381

fnv

Fowler–Noll–Vo hash function

z3

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

rand_pcg

Selected PCG random number generators

dissimilar

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

seahash

A blazingly fast, portable hash function with proven statistical guarantees

rand_distr

Sampling from random number distributions

robust

adaptive floating-point predicates for computational geometry

foldhash

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

simd-adler32

A SIMD-accelerated Adler-32 hash algorithm implementation

fastcdc

(content defined chunking) in pure Rust

sgp4

A pure Rust implementation of the SGP4 algorithm for satellite propagation

stringprep

algorithm

float_eq

Compare IEEE floating point primitives, structs and collections for equality

bvh

A fast BVH using SAH

ndarray-linalg

Linear algebra package for rust-ndarray using LAPACK

usearch

Smaller & Faster Single-File Vector Search Engine from Unum

oorandom

A tiny, robust PRNG implementation

gix-negotiate

gitoxide project implementing negotiation algorithms

nanorand

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

highway

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

easy-smt

Easily interact with an smt solver as a subprocess

earcutr

port of MapBox's earcut triangulation code to Rust language

histogram

A collection of histogram data structures

edit-distance

Levenshtein edit distance between strings, a measure for similarity

murmur3

hash

reed-solomon-simd

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

iroh-blobs

content-addressed blobs for iroh

topological-sort

Performs topological sorting

hnsw_rs

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

roots

well known algorithms for numerical root finding

regalloc2

Backtracking register allocator inspired from IonMonkey

differential-dataflow

An incremental data-parallel dataflow platform

resolvo

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

phf_codegen

Codegen library for PHF types

rand_regex

Generates random strings and byte strings matching a regex

bm25

BM25 embedder, scorer, and search engine

gxhash

non-cryptographic algorithm

rand_mt

Reference Mersenne Twister random number generators

special

The package provides special functions

argminmax

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

buffer-redux

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

rust-stemmers

some popular snowball stemming algorithms

rand_xoshiro

Xoshiro, xoroshiro and splitmix64 random number generators

medians

Median, Statistical Measures, Mathematics, Statistics

rustfst

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

rustc-stable-hash

A stable hashing algorithm used by rustc

gix-revwalk

providing utilities for walking the revision graph

float_next_after

A trait for native rust f64/f32 nextafter

intervallum

Generic interval and interval set library

levenberg-marquardt

algorithm built on top of nalgebra

metrohash

high quality, high performance hash algorithm

kd-tree

k-dimensional tree

arroy

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

pariter

Parallel iterator processing

nucleo

plug and play high performance fuzzy matcher

multimap

A multimap implementation

satkit

Satellite Toolkit

kdtree

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

geo-index

Fast, immutable, ABI-stable spatial indexes

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.

gemm

Playground for matrix multiplication algorithms

noise

Procedural noise generation library

vek

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

boyer-moore-magiclen

fast string search algorithm implemented in Rust

scirs2-interpolate

Interpolation module for SciRS2 (scirs2-interpolate)

interp

Matlab's interp1 function

varpro

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

yada

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

hax-lib

Hax-specific helpers for Rust programs

uuid7

UUID version 7

prio

aggregation system core: https://crypto.stanford.edu/prio/

libblur

Fast image blurring in pure Rust

skillratings

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

permutation

Small utility for creating, manipulating, and applying permutations

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

arma-rs

Arma 3 Extensions in Rust

vector-map

VecMap<K, V>: a Linear Search with Map API

raft

language implementation of Raft algorithm

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.

probminhash

Minhash algorithms for weighted Jaccard index

iter_tools

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

delaunay

A d-dimensional Delaunay triangulation library with float coordinate support

ext-sort

rust external sort algorithm implementation

linregress

ordinary least squared linear regression with some basic statistics

mt19937

A translation of the MT19937 Mersenne Twister rng algorithm to Rust

romu

A pseudo random number generator using the Romu algorithm

simple_endian

A create for defining endianness within your data structures, to make handling portable data structures simpler

alphanumeric-sort

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

rand_jitter

Random number generator based on timing jitter

k8s-openapi-ext

Collection of fluent builder traits for Kubernetes objects

symspell

Spelling correction & Fuzzy search

fitsrs

FITS image parser

partial_sort

provide a Rust version std::partial_sort

quad-rand

Pseudo random implementation with core atomics

clipper2

A polygon Clipping and Offsetting library for Rust

gcd

Calculate the greatest common divisor

slice-group-by

Iterators over groups in slices and strs

dmp

A high-performance library in that manipulates plain text

halfbrown

Multi backend HashMap for higher performance on different key space sizes

version-ranges

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

ndarray-slice

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

jubjub

elliptic curve group

libcrux-sha2

Formally verified SHA2 hash library

timely

A low-latency data-parallel dataflow system in Rust

poi

A pragmatic point-free theorem prover assistant

bao

BLAKE3 verified streaming

rexile

A blazing-fast regex engine with 10-100x faster compilation - now with complete Unicode safety

gryf

Graph data structure library with focus on convenience, versatility, correctness and performance

transvoxel

Eric Lengyel's Transvoxel Algorithm

ndarray-conv

N-Dimension convolution (with FFT) lib for ndarray

transpose

transposing multi-dimensional data

radsort

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

shortestpath

Shortest Path is an experimental library finding the shortest path from A to B

rustdct

Compute Discrete Cosine Transforms (DCT) of any size in O(nlogn) time, in pure Rust

columnar

Conversion from arrays of complex structs to simple structs of arrays

x12-types

Bindings for the ASC X12 EDI definitions

simplerand

fast random number generator

memx

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

astral-pubgrub

PubGrub version solving algorithm

flo_binding

Declarative binding library for Rust

cdshealpix

HEALPix tesselation

rustcrypto-ff

building and interfacing with finite fields

wyrand

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

ukraine

Glory to Ukraine. Library for transliterating Ukrainian Cyrillic text into Latin script representation

iptrie

IPv4/v6 prefixes lookup structures (based on tries)

bevy_math

math functionality for Bevy Engine

chalk-recursive

Recursive solver for the Chalk project

rectangle-pack

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

hyperloglog

in Rust

scnr2

Scanner/Lexer with regex patterns and multiple modes

russcip

Rust interface for SCIP

blake2_bin

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

ftui-render

Render kernel: cells, buffers, diffs, and ANSI presentation

kube_quantity

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

highs

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

ruvector-mincut

World's first subpolynomial dynamic min-cut: self-healing networks, AI optimization, real-time graph analysis

glissade

that provides various utilities for animations and transitions

lilt

running interruptable, transition based animations as a function of time

pldag

A DAG-based combinatorial-model framework with optional GLPK solving back-end

gis-tools

A collection of geospatial tools primarily designed for WGS84, Web Mercator, and S2

generic_a_star

A generic implementation of the A* algorithm

muxer

Deterministic, multi-objective bandit-style routing primitives (windowed stats + Pareto selection)

xiangting

calculating the deficiency number (a.k.a. xiàngtīng number, 向聴数).

i_key_sort

Counting sort algorithm

multiexp

Multiexponentiation algorithms for ff/group

anofox-regression

A robust statistics library for regression analysis

moc

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

census

Keeps an inventory of living objects

itermore

🤸‍♀️ More iterator adaptors

byteyarn

hyper-compact strings

bevy_knossos

generating and rendering mazes

rolling-stats

Rolling statistics calculations (min/max/mean/std_dev) over arbitrary floating point numbers based on Welford's Online Algorithm

random

The package provides sources of randomness

error_tools

Basic exceptions handling mechanism

line-clipping

implementing line clipping algorithms

arpfloat

Arbitrary-precision floating point library

adler2

clean-room implementation of the Adler-32 checksum

minstd

minimal standard MCG M31 random number generator

linfa-linalg

Pure-Rust implementation of linear algebra routines for ndarray

sdf_glyph_renderer

Tools for generating SDF font glyphs from bitmap images

easyfft

providing an easy FFT API for arrays and slices

anndists

some distances used in Ann related crates

cpd

Collaboration Pattern Detection: A tool to search for context-aware and relaxed frequent subgraphs in a graph database

gix-diff

Calculate differences between various git objects

fast_hilbert

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

changeforest

Random Forests for Change Point Detection

hexf-parse

Parses hexadecimal floats (see also hexf)

cam-geom

Geometric models of cameras for photogrammetry

garnish_lang_simple_data

Data implementation for garnish runtimes using simple list of variants

omeco

Tensor network contraction order optimization

quantiles

a collection of approximate quantile algorithms

daachorse

Double-Array Aho-Corasick

mosaik

runtime for building self-organizing, leaderless distributed systems

cubecl-zspace

CubeCL ZSpace Library

vector-traits

Rust traits for 2D and 3D vector types

par-iter

Fork of rayon, with chili support

subsume

Geometric box embeddings: containment, entailment, overlap. Ndarray and Candle backends.

libcrux-hkdf

Libcrux HKDF implementation

adler32

Minimal Adler32 implementation for Rust

mpchash

A space-efficient (no need for vnodes) multi-probe consistent hashing algorithm

pymath

A binary representation compatible Rust implementation of Python's math library

scirs2-integrate

Numerical integration module for SciRS2 (scirs2-integrate)

genetic_algorithm

A genetic algorithm implementation

linestring

line string toolbox

swiftnav

GNSS positioning and related utilities

ncollide3d-updated

2 and 3-dimensional collision detection library in Rust. Will be superseded by the parry3d crate.

fractional_index

fractional indexing

hydra-amm

Universal AMM engine: build, configure, and operate any Automated Market Maker through a unified interface

ufotofu

Abstractions for lazily consuming and producing sequences

cobyla

optimizer for Rust

petal-neighbors

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

wolfe_bfgs

A dense BFGS optimization algorithm in Rust, with a Strong Wolfe line search and initial Hessian scaling

strength_reduce

Faster integer division and modulus operations

pyinrs

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

tenthash

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

pubgrub

version solving algorithm

sketches-ddsketch

A direct port of the Golang DDSketch implementation

pumpkin-core

The core of the Pumpkin constraint programming solver

volute

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

graaf

Work with directed graphs

scapegoat

Safe, fallible, embedded-friendly ordered set/map via a scapegoat tree. Validated against BTreeSet/BTreeMap.

trackball

Virtual Trackball Orbiting via the Exponential Map

iter-read

A Read implementation for iterators over u8 and related types

lt-fm-index

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

innr

SIMD-accelerated vector similarity primitives (dot, cosine, norm, maxsim, matryoshka, clifford rotors)

rs-math3d

Rust 3D Math (no dependency on std)

GSL

binding for the GSL (the GNU scientific library)

ruvector-mincut-gated-transformer

Ultra low latency transformer inference with mincut-gated coherence control

wezterm-bidi

The Unicode Bidi Algorithm (UBA)

cardinality-estimator-safe

Estimate the cardinality of distinct elements in a stream or dataset with no unsafe code

ratio-color

Ratio's color palette management in Rust, built on 'palette' and 'enterpolation'

rdst

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

rust-sugiyama

Sugiyama's algorithm to calculate coordinates of a directed graph

bpe

Fast byte-pair encoding implementation

graphrs

package for the creation, manipulation and analysis of graphs

downstream

efficient, constant-space implementations of stream curation algorithms

addchain

Generate addition chains

merkle_hash

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

od_opencv

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

advent-of-code

Solutions to Advent of Code

sfcgal

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

colorimetry

Rust Spectral Colorimetry library with JavaScript/WASM interfaces

lunk

Event graph processing

noise-functions

A collection of fast and lightweight noise functions

qr2term

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

xml-3dm

3-way XML diff and merge tool

twofloat

Double-double arithmetic functionality

togo

2D geometry, providing geometric algorithms for intersection/distance between circular arcs/line segments

incremental

computations, based on Jane Street's incremental

levenshtein

algorithm

lightweight-system-monitor

A Linux system monitor so lightweight even floating point math is prohibited

didppy

Python interface for Dynamic Programming Description Language (DyPDL) and DyPDL solvers

vpsearch

Vantage Point Tree search algorithm for fast nearest neighbour search in multi-dimensional metric spaces

veg

Flexible tables

weighted_path

finding shortest paths in weighted graphs using Dijkstra's algorithm with multiple heap implementations

ord_subset

Tools for working with the Ord subset of certain PartialOrd types, like floats

qlora-rs

4-bit quantized LoRA (QLoRA) implementation with dual GGUF and Candle native export for Rust

ruvector-math

Advanced mathematics for next-gen vector search: Optimal Transport, Information Geometry, Product Manifolds

rand-unique

A no-std crate for generating random sequences of unique integers in O(1) time

orx-v

Traits to unify all vectors!

english-to-cron

converts natural language into cron expressions

chalk-engine

Core trait engine from Chalk project

muldiv

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

instant-distance

Fast minimal implementation of HNSW maps for approximate nearest neighbors searches

runmat-accelerate-api

Common API types for RunMat GPU acceleration backends

boostvoronoi

Boost voronoi ported to 100% rust

scte35

creating and parsing SCTE-35 (Society of Cable Telecommunications Engineers) messages with zero-dependency

ceres-solver

Safe Rust bindings for the Ceres Solver

tlsh2

TLSH algorithm

opensearch-dsl

Strongly typed OpenSearch DSL

dypdl

Libarary for Dynamic Programming Description Language (DyPDL)

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'

rithm

Arbitrary precision arithmetic

triple_accel

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

swc_feature_flags

Feature flag transformation for SWC - build-time marking and runtime dead code elimination

cbor-data

using CBOR as in-memory representation for working with dynamically shaped data

fast_polynomial

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

tf2-price

Team Fortress 2 item pricing

feruca

Unicode Collation Algorithm

single-svdlib

port of LAS2 from SVDLIBC

discrete

Combinatorial phantom types for discrete mathematics

type-map

typemap container with FxHashMap

runtime_units

A run-time Rust library for working with units of measurement and conversions between them

funspace

N-dimensional function spaces and transforms

embeddenator-vsa

Vector Symbolic Architecture operations for sparse ternary representations

option-chain-orderbook

A high-performance Rust library for options market making infrastructure, providing a complete Option Chain Order Book system built on top of OrderBook-rs, PriceLevel, and OptionStratLib

flowstats

Collection of stream analytics algorithms: cardinality, quantiles, frequency, sampling, and more

frd_pu

A high-performance, zero-dependency library for creating efficient and fast applications

ratio-genetic

Ratio's genetic algorithms library

rsc_osrm

rust wrapper for osrm, folk from TehGoat/rs_osrm

general-sam

A general suffix automaton implementation in Rust

random_word

Efficient functions for generating random words in many languages

mirror-mirror

Reflection library for Rust

nabla-ml

A numpy-like library for Rust

scru128

Sortable, Clock and Random number-based Unique identifier

bxvl

A datatype library that allows for measurement unit association, conversion, and operations for values

entropy

Calculates the Shannon entropy of arrays of bytes and strings

baby_shark

Geometry processing library

fgumi-umi

UMI assignment strategies and utilities for fgumi

gat-lending-iterator

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

hill_descent_lib

Genetic algorithm library for n-dimensional optimization problems

yaspar-ir

few representations of SMT scripts and other functionalities

iter-merge

A high-performance iterator merging library

raftbare

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

orasort

High-performance, cache-efficient sorting library optimized for common prefixes

cdk-ansible

generate Ansible playbooks from Rust code

fontkit

font loading and indexing

treediff

Find the difference between arbitrary data structures

lucid-core

Reconstructive memory retrieval engine using ACT-R spreading activation

quadtree-f32

dependency-free ID-based quadtree

eta-algorithms

Low overhead data structures focused on performance

anomaly-grid

Sequential pattern analysis through variable-order Markov chains. Built for detecting deviations in finite-alphabet sequences.

dory-pcs

A high performance and modular implementation of the Dory polynomial commitment scheme

cantrip

Practical extension methods for standard Rust collections

moyo

Crystal Symmetry in Rust

hidreport

HID Report Descriptor and HID Report parser

fnv_rs

Fowler–Noll–Vo hash function including 32, 64, 128, 256, 512, & 1024 bit variants

arrow-row

Arrow row format

lp-solvers

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

radiate

genetic algorithms and artificial evolution

keyforge95

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

terseid

Adaptive-length, collision-resistant short IDs

rustframe

dataframe and math toolkit

next-plaid

CPU-based PLAID implementation for multi-vector search using ndarray

bit-iter

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

evalica

your favourite evaluation toolkit

sosorted

A set of methods to efficiently manipulated sorted arrays

blstrs_plus

High performance implementation of BLS12 381

cmsis_dsp

Bindings to the CMSIS DSP library for ARM Cortex-M processors

microcad-lang

µcad language

kotoba-rewrite

Advanced graph rewriting engine implementing DPO transformations

computation-process

defining stateful computations (and generators) that support suspend/resume, interleaving, cancellation and serialization

xsum

Fast Exact Summation of Floating-Point Numbers

crc64

checksum implementation

jax-rs

JAX in Rust - A complete machine learning framework with WebGPU acceleration

sat-solver

A SAT solver implemented in Rust, focusing on performance, efficiency and experimentation

chunkrs

A high-performance, deterministic, flexible and portable zero-copy streaming Content-Defined Chunking (CDC) and hashing infrastructure library. Bytes in → Chunks & hashes out

koopman-checksum

Koopman checksum algorithm implementation. The Koopman checksum provides 1- and 2-bit fault detection for significantly longer data words than traditional dual-sum checksums like Adler or Fletcher.

dbsp

Continuous streaming analytics engine

dogear

merging bookmark trees

simple-easing

Set of simple easing functions

oxide-arbiter

A CLOB order matching engine with price-time priority, limit/market orders, and four time-in-force policies

ndarray-rand

Constructors for randomized arrays. rand integration for ndarray.

autour_core

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

solar-positioning

High-accuracy solar positioning algorithms (SPA and Grena3) for calculating sun position and sunrise/sunset/twilight times

ruvector-nervous-system

Bio-inspired neural system with spiking networks, BTSP learning, and EWC plasticity

safe-bigmath

non-overflowing, non-panicking numeric types as well as safe big integer and decimal that can scale to any size safely and gracefully, only wasting memory when extra precision is needed

ftui-layout

Flex and grid layout solvers for FrankenTUI

four-bar

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

raft-log

Raft log implementation

tree_traversal

Find best leaf node in a tree

moku

creating hierarchical state machines (HSM)

geo-clipper

Boolean operations on polygons

wcs

FITS World Coordinate System (WCS)

passwords

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

deep_causality

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

matchsorter

Fuzzy string matching and sorting, inspired by match-sorter

motif-rs

A modular matrix profile library for time series analysis

mapproj

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

arcos-kdl

ARCOS-Lab Kinematics and Dynamics Library

axtask

ArceOS task management module

munsellspace

High-precision sRGB to Munsell color space conversion with 100% reference accuracy

finetime

High-fidelity time library for applications where sub-nanosecond accuracy and exact arithmetic are needed

kand

Pure Rust technical analysis library inspired by TA-Lib

pingora-limits

rate limiting and event frequency estimation

kcr_operator_cluster_x_k8s_io

Kubernetes Custom Resource Bindings

rand_aes

AES based pseudo-random number generator

solvr

Advanced computing library for real-world problem solving - optimization, differential equations, interpolation, statistics, and more

arcweight

A high-performance, modular library for weighted finite state transducers with comprehensive examples and benchmarks

wyhash

fast portable non-cryptographic hashing algorithm and random number generator

nozomi

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

fsum

calculate accurate sum of floats

fast-posit

Software implementation of the Posit floating point format

surrealex

Dead simple SurrealDB query generator

fuzzy-muff

Fuzzy Matching Library

bellman

zk-SNARK library

h3o-zip

A compression scheme tailored for H3 cell indexes

data_structure

implementing and managing common data structures

smesh

A fast and ergonomic surface-mesh/halfedge-mesh implementation and polygon mesh manipulation library based on pmp

foxstash-core

High-performance local RAG library - SIMD-accelerated vector search, HNSW indexing

padder

A highly efficient Rust crate for padding data during runtime

cvmcount

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

arrayfire

high performance software library for parallel computing with an easy-to-use API. Its array based function set makes parallel programming simple. ArrayFire's multiple backends (CUDA…

la_dfa_2_dot

Create graphs from lookahead DFAs generated by parol

dagga

For scheduling directed acyclic graphs of nodes that create, read, write and consume resources

usher

Parameterized routing for generic resources in Rust

garbongus

Fluid mechanics library: pipe sizing, pump power, Manning equation, multi-segment pipelines, seawater properties, Bernoulli, Darcy-Weisbach, vacuum lift, capillary rise. Pure Rust, zero dependencies.

broccoli

broadphase collision detection algorithms

reed-solomon-novelpoly

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

selen

Constraint Satisfaction Problem (CSP) solver

avalog

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

adskalman

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

hime_redist