Data Structures

A collection of object pools, for more efficient dynamic memory allocation

Blockbuffers is a serialization tool which builds strict Flatbuffers binaries.

Froggy is a prototype for the Component Graph System programming model. It aims to combine the convenience of composition-style Object-Oriented Programming with the performance close to Entity-Component Systems.

A static hashmap implementation, based on the Round-Robin hashing algorithm found in rustc.

Rendezvous hashing with support for tag-based exclusions

A pool which manages allocation of unique indices. Acts like a psuedo-memory allocator.

A vector-based sorted map, set and keyed-set implementation

An immutable ordered map and set based on weight-balanced tree.

An incremental collections library making use of Adapton

Shared, reference-counted, copy-on-write, single-pointer buffers

Simple bounded binary heap

A small Rust library that allows users to reinterpret data of certain types safely.

Generic Publish / Subscribe model for application messaging

Ergonomic, garbage collected strings for Rust

A possibly-stack-allocated string with generic bytes storage

Lock-free concurrent hash map: elements never move after insertion, enabling lock-free reads

A fast mpmc broadcast queue

Tranches are an alternative to slices

simple, immutable, flat k-d tree

An addressable pairing heap implementation.

Memory order consume for when it's known that the compiler can't elide the dependency

Digits iteration for unsigned integer types.

Type level sized vectors

CRDTs for common data structures like maps, sets, vecs, strings, and JSON

Dynamically typed keys for associative arrays.

succinct bit vector

Tarjan's zip tree implemented in Rust

Next-gen MTA. Secured, Faster and Greener

A Hashed type you can convert any hashable type into and still do equality checks on

A simple RDF N-Triples parser

Tools for dot map representations of serde_json Maps

In memory array de-duplication, useful for efficient storing of a history of data versions.

Finite State Machines with a procedural builder-style API and compile time transition checks.

High-performance, schema-agnostic, backend-agnostic event bus

This package implements a basic version of the PQ-Grams tree-edit-distance approximation algorithm, as generically as possible. It defines traits that you can define for your label-types and tree-types, to use custom types with the algorithm. It also defines a basic generic Tree type for string or integer leaf types that is easy to build with, and compatible with the algorithm.

Implementations of Suffix Array, Burrows-Wheeler Transform and FM-index

succinct dictionary

MBrane implementations in Rust

A queue for unique indices with constant-time query and removal

A sketch implementation of anonymous, tagged unions in stable Rust

Fuel-metered JSONLogic guard evaluation with per-call custom operators — forked from jsonlogic-rs

Low-level Judy array FFI binding

Lock-free SPSC and MPSC byte ring buffers for logging and archival

A vector using an external slice as backing storage

A small tool for representation/class invariants

Basic environments for Kailua

A simple Range representing nonempty ranges.

Meta type information and type reflection at compile-time and runtime.

Comprehensive, correctly rounding interval arithmetic library.

A simple, dependency-less HTTP-header builder and parser