Algorithms and Data structures

Unified access to tabular data

A fast consistent hash ring implementation in Elixir.

Jump consistent hash implementation in Elixir

Computational parallel flows for Elixir

General purpose circular buffer.

Raft library

A high-performance graph datastructure library for Elixir projects with multigraph support

Generic Zipper Implementation for Erlang

Erlang Trie Implementation

Library for boolean satisfiability solving and expression manipulation.

Murmur is a pure Elixir implementation of the non-cryptographic hash Murmur3. It aims to implement the x86_32bit, x86_128bit and x64_128bit variants.

A fast consistent hash ring implementation in Elixir

A high-performance graph datastructure library for Elixir projects

A faster Map, augmented with a MerkleTree

Implementations of δ-CRDTs

Erlang/Elixir library for partitioned or sharded ETS tables.

Parallel stream operations for Elixir

A bitwise radix tree for prefix based matching on bitstring keys of any length.

ETS-based partitioned buffer for high-throughput data processing

Fast bounded deque using two rotating lists.

Simple Elixir queue, with a constant-time `size/1` and a maximum capacity.

Elixir implementation of bidirectional map and multimap

A `:queue` wrapper with improvements in API and addition of Protocol implementations

A simple, dependency free boolean satisfiability solver.

Consistent Hash Ring

Jump Consistent Hash NIF library for Erlang/Elixir.

Small composable Heap implementation. Heaps sort elements at insert time.

A splay-tree implementation

Tries in Gleam

A pure Gleam package to compute the edit distance of two strings

Elixir library computing simple combination and permutation on Enumerables.

Algebra utilities for Elixir

Non-empty lists in Gleam

An OTP application

Immutable arrays for Gleam

Data structures for the EYG IR

Implementation of the Ramer–Douglas–Peucker algorithm for reducing the number of points used to represent a curve.

Ordered map for Elixir lang

A high-performance, concurrent, and mutable Cuckoo Filter for Erlang and Elixir

Bags (or multisets) in Gleam

A library for cosine similarity & simhash calculation

Real-valued intervals with support for the `Enumerable` protocol.

Merkle Trees for data replication purposes

A comprehensive pure Elixir graph algorithm library

An Elixir implementation of the Google diff_match_patch library.

NaryTree implements the data structure for n-ary tree (also called rose tree), where each node in the tree can have zero or more children. NaryTree provides methods for traversal and manipulation of the tree structure and node contents.

Traverse is a toolset to walk arbitrary Elixir Datastructures in a functional way.

Simple implementation of standard animation easing functions.

Well-structured Arrays with fast random-element-access for Elixir, offering a common interface with multiple implementations (MapArray, Erlang :array, etc.) with varying performance guarantees that can be switched in your configuration.

Erlang Priority Queue Implementation

A hash tree or Merkle tree is a tree in which every non-leaf node is labelled with the hash of the labels or values (in case of leaves) of its child nodes. Hash trees are useful because they allow efficient and secure verification of the contents of large data structures.

Ethereum's Merkle Patricia Trie data structure

Constraint Programming Solver

Helper functions for working with weighted random values.

Vault: a process-scoped hierarchical data storage library

Use `:atomics` as a bit array or as an array of N-bit counters.

Double-ended queue with limited length

sets-like wrapper based on maps

GenStagA data type and related functions to support an unrooted (multiple starting nodes) polytree (a tree-like graph with edges).

riak CTDT datatypes

Probabilistic data structures powered by atomics. Bloom filter, Counting bloom filter, Linear counter (cardinality)

A distributed, strongly-consistent key-value store built on Raft

Storing a set of closed intervals

DuckDB-native dataframe library for Elixir

Compositional, resource-safe streams for Gleam — runs on Erlang and JavaScript targets

Elixir bindings for PyVRP - a state-of-the-art vehicle routing problem solver

hybrid logical clock

A simple table library for Gleam

ETS trie to match keys

Trie based router.

A circular buffer backed by a queue, map, or ETS

The datamodel document and what can be decided from it: the typed three-scope declaration, its named record and shape types, the path/type index, the read check, compatibility and coverage - pure functions, no dependency on the block editor, the compiler or the UI

RingBuffer - size limited queue, like a ring or cyclic buffer. With non blocking and non locking writers.

Satellite toolkit for Elixir with SGP4 propagation, coordinate transforms, GNSS positioning, orbit determination, conjunction assessment, pass prediction, live TLE/OMM data, real-time tracking, and a Rust NIF backend.

Data structures in pure Gleam! Including tree, heap, non empty list, map, set, and priority queue.

Mutable data structures

Edit distances, similarity scores, LCS, and diff for Gleam.

A double-ended queue data structure

Dependency graphs for optimal function call ordering