Utilities

A tiny resource-pool implementation

Track ownership of resources across processes.

Context carries request scoped values and deadlines

A hunky Erlang worker pool factory

BEAM friendly spinlocks for Elixir/Erlang

A library for defining structs with a type without writing boilerplate code.

Faker is a pure Elixir library for generating fake data.

UUID generator and utilities for Elixir.

UUID generator and utilities for Elixir.

Deep (recursive) merging for maps, keyword lists and whatever else you may want via implementing a simple protocol.

Exponential backoffs library

Provides UUID generation, parsing, and formatting. Supports RFC 4122, and the v6 draft extension

Simple Elixir macros for linear retry, exponential backoff and wait with composable delays.

Efficient batch loading in Elixir

A UUID v7 implementation and Ecto.Type for Elixir

Pagination for the Elixir ecosystem

Map, Calendar, Digits, Decimal, HTTP, Macro, Math, and String helpers for ex_cldr.

Erlang UUID Implementation

Lazy, external iterators for Elixir.

Translates Elixir functions to match specifications for use with `ets`.

Elixir library for working with Money safer, easier, and fun, is an interpretation of the Fowler's Money pattern in fun.prog.

Elixir fake data generation for testing and development

Simple, fast, flexible and efficient generation of probably unique identifiers (`puid`, aka random strings) of intuitively specified entropy using pre-defined or custom characters.

Providers provider.

Fast semaphore using ETS.

Additional standard library for Erlang

A library to serialize between maps and nested structs

UUID v7 with an 18-bit randomly-seeded counter. (Re: Section 6.2, from the IETF Draft.)

A dependency-free utility library containing 100+ useful functions.

OS Process Manager

Elixir port of NanoID (https://github.com/ai/nanoid), a tiny, secure URL-friendly unique string ID generator.

Calculates the difference between two (nested) maps, and returns a map representing the patch of changes.

This library fills a bunch of important niches. A Maybe can help you with optional arguments, error handling, and records with optional fields.

Countries is a collection of all sorts of useful information for every country in the [ISO 3166](https://de.wikipedia.org/wiki/ISO_3166) standard.

Erlang utility modules from ProcessOne

Morphix is a small package of convenience methods for working with Maps, Tuples, and Lists.

Implementation of the purl (package url) specification

User agent parser library

Coerce allows defining coercions, standardized conversions, between data types.

A bunch of helper functions, intended to make life easier

Implementation of `blank?` in Elixir. Aims to work in a practically identical fashion to ActiveSupport's #blank? method.

Unfold values on-demand from a function

Colour types, conversions, and other utilities

Zero dependency platform detection library for gleam

A small utility to convert deep Elixir maps with mixed string/atom keys to atom-only keyed maps

A declarative busy wait

An Elixir friendly Enum module generator that can be used by itself or with Ecto.

ShortUUID - generate concise, unambiguous, URL-safe UUIDs

A Pure Random Number Generator

Boolean expression engine for domain rules

Generic setup application for Erlang-based systems

Browser detection library

RedisMutex is a library for creating a Redis lock for a single Redis instance

Interact with external programs with back-pressure mechanism

A maintained fork of Faker. A pure Elixir library for generating fake data.

Difference library

process pipe library

k-ordered unique identity

Elixir library providing various ways of waiting for things to happen

A delightfully simple monad library that's written for Elixir.

A tiny tabular table renderer

Generates identifiers like: cus_01EPEY1JMKXVBT and txn_01EPEY2P06TR1RTV07XA82ZGJJ. Includes Ecto type.

Split a stream into a head and tail, without iterating the tail

Run interactive shell commands on the BEAM

Generate and parse UUIDs

Drill down into a nested map and filter out keys according to user specified values

Functional lenses for nested structures

Manage headless Chrome instances via the Chrome DevTools Protocol

Shared browser automation contract and pool implementation for Elixir browser backends

Universally Unique Lexicographically Sortable Identifier (ULID) in Elixir.

Remodel is an Elixir presenter package used to transform data structures. This is especially useful when a desired representation doesn't match the schema defined within the database.

This package implements a simple mutex as a GenServer. It allows to lock keys and handles locking multiple keys without deadlocks.

Collection of Awesome Elixir shortcuts and utilities ⚡

Send a message to the BEAM from a shell script

Create singleton values accessible anywhere in your application.

Elixir port of Breadcrumble library

Low level pooling library

An :elixir_uuid compatibility layer for :uniq

Deadline is a small library for managing deadlines and deadline propagation.

This small library allows the deep iteration / mapping of Enumerables.

Debouncer is a flexible function call debouncer.

Handy functions for polling, rate limiting, and receiving.

BeamLabCountries is a collection of all sorts of useful information for every country in the [ISO 3166](https://wikipedia.org/wiki/ISO_3166) standard.

Extensions to the Erlang maps module

UUID generator and utilities for Elixir.

Generate YouTube-looking IDs from numbers

Faker is a pure Elixir library for generating fake data.

Utility function to efficiently merge Tailwind CSS classes in Elixir without style conflicts.

Diff, match patch implementation

A utility for working with nested data structures.

An Elixir module for generating Gravatar urls.

Toolkit for handling binaries in Elixir.

The library for managing pools of workers.

Copy and paste from system clipboard

Chameleon is a utility for converting colors from one color model to another. Conversions can be made to/from RGB, CMYK, Hex, HSL, Pantone, and even Keywords. For example: "FFFFFF" -> %{c: 0, m: 0, y: 0, k: 0}

Placeholders for data that isn't loaded. Inspired by Ecto.

A Gleam package to help you thread state through a series of steps.

TypedStructor is a library for defining structs with types effortlessly.

Elixir library for generating random and unique names

A flexible type mapping system for Elixir struct modules

Extensions for Elixir structures.

Convert different mappable types to each other in Elixir

Chained, semantic comparisons for Elixir

Universally Unique Lexicographically Sortable Identifier

A secure, non-evaling condition (boolean predicate) engine for end users

A tailwind utility library for Elixir

Tools for building Gamend plugins (hooks).

Numerator does calculate paginations without creating any markup.

SDK for Gamend hooks development. Provides type specs, documentation, and IDE autocomplete for Gamend modules without requiring the full server.

Constants and Enumerated Values for Elixir

Experimentations with Redraw, to provide better or simpler API.

Provide read and write buffers for Elixir

Fast no copy globals for Elixir & Erlang.

128-bit, k-ordered, conflict-free IDs Elixir.

create ranges over any type

A helper to run functions that you want to limit by heap size or time

Tools to handle three common return values in Elixir: `:ok | {:ok, value} | {:error, reason}`

Lazy implementation of Kernel.SpecialForms.for/1 based on streams

A type-safe, K-sortable, globally unique identifier inspired by Stripe IDs

Crudry is a library for DRYing CRUD.

Helpers for waiting on asynchronous events

Utility function to efficiently merge Tailwind CSS classes in Elixir without style conflicts.

Dependency injection and resolution at compile time or runtime

Collection of useful data types brought to Elixir from other functional languages.

ksuid is a zero dependency Elixir library for generating KSUIDs.

Autonomous payment capabilities for Raxol agents. x402/MPP auto-pay, wallet management, spending controls, and cross-chain settlement.

A collection of useful functions for building Elixir apps.

Tiny library to convert from "encoded" maps to Elixir structs.

Nil protection for nested maps and structs

A library to work with EMV QR Code Specification for Payment Systems

Tools for building GameServer plugins (hooks).

Simple functions for coercing Elixir Maps: atomizing, snake_casing, etc.

Unsurprisingly, MapKeys is a module for manipulation of map keys

Execution Plane process launch, stdio, PTY, and process-session runtime.

Extension of the Elixir standard library focused on data stuctures, data manipulation and performance

Construct streams of values by specifying composable generator functions. For example list(tuple(like: {atom, string})) will generate a random length keyword list with random keys and values. Constraints can be applied at all levels.

A wildcard matching library that implements unix-style blob pattern matching functionality for Elixir binaries. It works on all binary input and defaults to working with codepoint representations of binaries, but other modes are also available.

Resuable utilities for projects generated with oas_generator for Open API Spec, JSON schema and MCP client or server.

The Currying library allows you to partially apply (or 'curry') any Elixir function, in a very transparent way. It also optionally implements the infix operator `~>` as a synomym for currying.

Random parameter generation for Ash resources.

Fab is a lightweight Elixir library for generating fake data

Type conversion library for Erlang and Elixir.

Fab.Person is an Elixir library for generating random information about a person

Fully featured KSUID module in Elixir

Fab.Company is an Elixir library for generating random information about a business

Decentralized, k-ordered ID generation service

Provides simple debounce and throttle functionality

Generates random strings

Buffalo - deduplicated erlang apply

A cross-platform Gleam library for executing shell commands.

A Utilitary package functionalities modules for improve a secure performatic development.

Both total and time limited evaluation of expressions

A Gleam library for spawning OS processes.

A common pattern to acquire a resource, perform some action on it and then run a finalizer, regardless of the outcome of the action

Elixir Password Generator

Dependency injection for Elixir. Zero code changes required.