ElixirToolbox

A curated list of libraries

General Libraries ▷ Plug ▷ Phoenix ▷ Absinthe ▷ Ecto ▷ Nerves ▷ Tooling ▷ Database (non-Ecto) ▷ Cowboy ▷ Erlang Specific ▷ Rebar ▷ Languages Integration

General Libraries

BN128 elliptical curves

BSON

cyanide

Background jobs (CloudI)

cloudi_core

Background jobs queue

toniq

Background jobs queue (Mnesia)

que

Background jobs queue (PostgreSQL)

rihanna

Background jobs queue (Redis)

verk

flume

Background jobs queue (Resque/Sidekiq)

exq

Background tasks runner

tarearbol

Base conversion

custom_base

Base58 encoding/decoding for Elixir

b58

erl_base58

Base62 encoder/decoder

base62_uuid

base62

erlang_base62

Base64 encode/decode

Base

Base64 encode/decode, C NIF

b64fast

Batch message passing between Erlang/Elixir nodes

manifold

Beanstalkd client

elixir_talk

Behaviours reflection

behaviour_reflection

Benchmarking

benchee

erlperf

Bencode encoder/decoder, BitTorrent

ex_bencode

Bidirectional map and multimap

bimap

Binary data compression (Huffman encoding)

huffman

Binary hex dumping

dumpster

Binary pretty printer

binpp

Binary search

ebils

Bitmaps

bitmap

Bloom filters

bloomex

erbloom

Bluetooth

harald

blue_heron

Browser detection

browser

Burner (temporary) email address detector

burnex

Business forms generator

form

Business logic components framework

opus

Business rules, specification pattern

brex

CQRS/Event Store

commanded

incident

CRDT

delta_crdt

CSV encode/decode

csv

nimble_csv

Caching (ETS)

cachex

cache

Caching, adapter based

nebulex

Caching, in-memory KV store

cache_tab

Calendar recurring events

cocktail

Cassandra CQL client

cqerl

Chaos engineering testing

havoc

chaos_monkey

Charting/graphing

contex

Chat bot framework, XMPP

hedwig

Checksum (Luhn algorithm)

luhn

Chess for game servers

binbo

Circuit breaker

fuse

Circular buffer

circular_buffer

Classless Inter-Domain Routing (CIDR)

inet_cidr

cidr

erl_cidr

Cloudl process groups

cpg

Cluster RPC

backwater

Cluster automatic formation/healing

libcluster

cloister

Cluster automatic node discovery

nodefinder

Clustered app distribution

horde

Clustered app testing

local_cluster

Code profiler

exprof

Code reloader

exsync

lettuce

Colorized terminal output

nebula

Command line argument parsing

OptionParser

Command-line (CLI) app framework

clique

Command-line (CLI) options parser

getopt

Command-line (CLI) progress bars and spinners

progress_bar

Configuration at runtime

vapor

confex

Connection processes behaviour

connection

Consensus protocol, HoneyBadgerBFT

erlang-hbbft

Consensus protocol, raft

Coordinate conversion with OSGeo PROJ.4

proj

CouchDB client

couchdb

Country information (ISO 3166)

countries

Coverage Reports for Elixir

coverex

Cron-like job scheduler

quantum

erlcron

ecron

Crontab expressions

crontab

Cryptocurrency blockchain algorithms

caustic

Cuckoo filters

cuckoo_filter

Data structure to HTML

sneeze

Data validation

vex

norm

0.1.0

Database enumerable type

exnumerator

Date/time advanced formatting

calendar

Date/time helpers

timex

Date/time parser

date_time_parser

Date/timezone handling

qdate

Debugger

http://erlang.org/doc/apps/debugger/debugger_chapter.html

Deep merge for data structures

deep_merge

Dependency injection

definject

Dependency security audit

mix_audit

Deprecation logger

deppie

Dice roll simulator

rollex

Directory traversal

dir_walker

Distributed application server, TCP/MQTT/WebSocket

n2o

Distributed in-memory Caching with pub/sub

Distributed leader election

evel

Domain model validations

exop

Domain modelling typesafe structs

domo

EDN encoder/decoder

eden

erldn

EPUB generator/parser

bupe

EXIF metadata

exif_parser

erlang_exif

Elasticsearch bulk inserter

elasticsearch_elixir_bulk_processor

Elasticsearch client

elastic

elasticsearch

elastix

Email antivirus, ClamAV client

clamex

clamxir

Email delivery

bamboo

swoosh

mailman

Email message builder (RFC2822)

mail

Email send and receive

mailroom

Email templates, responsive

mjml

Emoji clock generator

emojiclock

Emoji encoding

exmoji

Encryption

cloak

Encryption (Mix)

encrypt

Encryption for binaries

cipher

Enumerate deep data structures

iteraptor

Environment variable caching

stillir

Environment variables (.env)

dotenv

Environment variables helper

env_helper

Erlang Term Storage (ETS) based key/value storage

con_cache

Erlang Term Storage (ETS) match specifications from Elixir functions

ex2ms

Erlang Term Storage (ETS) table persistence

persistent_ets

eternal

Erlang terms memory info

erlang_term

Error handling/exceptions

exceptional

Ethereum ABI

ex_abi

Ethereum RLP (Recursive Length Prefix) encoding

ex_rlp

Ethereum RPC client

exw3

Ethereum client

ethereumex

Event bus

event_bus

Event processing and monitoring

goldrush

Event sampler

deigma

ExUnit assertions

assertions

ExUnit assertions macros

assert_value

ExUnit expression result output (Power assert)

power_assert

ExUnit recursive matching

test_match

ExUnit test desktop notifications

ex_unit_notifier

Exceptions notifier

boom_notifier

Exponential backoff, linear retry, wait

retry

backoff

FFmpeg video processing

ffmpex

FTP client

https://erlang.org/doc/apps/ftp/

Fake data generator

faker

Faktory background job server client

faktory_worker

Fast Mersenne Twister (SFMT) for SIMD

sfmt

Feature flags

fun_with_flags

Feature/integration tests, Webdriver

wallaby

hound

File attachment/storage/upload

waffle

trunk

File sizes, human adable

sizeable

File system change events

ex_guard

File system manipulation

File

File type/format detection

format_parser

Filename sanitization

zarex

Finite State Machine (FSM)

machinery

Finite State Machine (FSM), graph generator

machinery_display

Folsom metrics storage (DalmatinerDB)

folsom_ddb

FreeSWITCH event sockets

event_socket_outbound

Functional programming helpers (combinators, currying, partial application)

quark

Fuzzy string matching

the_fuzz

GGSN/P-GW

ergw

GTIN code validation

ex_gtin

GUI

scenic

https://erlang.org/doc/apps/wx/chapter.html

Game networking, RakNet client

elixir-raknet

GenServer helpers

exactor

Generic programming/option types/data structures

datum

Genetic algorithms

genex

Geocoder with cache

geocoder

Geographic Information System (GIS), WKB/WKT/GeoJSON encode/decode

geo

Geohash encode/decode

geohash

geohax

Geolocation distance/bearing calculation

geocalc

Geometric/geographic distance calculations

distance

Geometry spacial relationship calculator

topo

Git changelog generation

changex

Git hooks

git_hooks

Graph data structure

libgraph

GraphQL client

neuron

Group actions

together

HTML builder DSL

temple

HTML entity string decode/encode

html_entities

HTML parser

fast_html

HTML parser and query

floki

meeseeks

HTML sanitizer

html_sanitize_ex

HTML tag-safe string truncation

curtail

HTML templates

temple

HTML templates, Slim-like

slime

HTML to PDF conversion

pdf_generator

puppeteer_pdf

chromic_pdf

HTTP client

finch

mint

tesla

hackney

HTTP client, REST

restc

HTTP cookies

HTTP middleware

raxx

HTTP performance/load testing

chaperon

HTTP proxy

http_proxy

vegur

HTTP request/response recording

exvcr

HTTP response mocks

mock_me

HTTP web server and client

ace

HTTP/1.1, HTTP/2 and Websocket client

gun

shotgun

HTTP/SSH request/response recording

walkman

HTTP2 client

kadabra

katipo

Haiku-like random ID generator

haikunator

Hardware I/O interfaces for GPIO, I2C, SPI

elixir_ale

Hashing algorithm, consistent

hash_ring

Hex code encoding/decoding

hexate

Hex semantic versioning

eliver

Hostname verification

ssl_verify_hostname

Hot reload/recompile on file system changes

active

sync

Human friendly ID generator

friendlyid

IBAN/BIC code validation

bankster

ICalendar files

icalendar

ID hashing

hashids

IRC bot framework

kaguya

IRC client adapter

exirc

Identicons generator

idicon

Image manipulaton/conversion

imageflow

eimp

Image metadata and validation

ex_image_info

Image processing (GraphicsMagick)

Image processing (ImageMagick)

mogrify

Interactive code notebook (like Jupyter)

livebook

Interactive computing (Jupyter notebook)

ielixir

Internationalization and localization

gettext

linguist

trans

Internationalized Domain Names in Applications (IDNA)

idna

IoT GUI framework

scenic

IoT framework

astarte

grisp

achlys

JSON Object Signing and Encryption (JOSE)

jose

JSON Web Tokens (JWT) (RFC 7519)

joken

JSON encoder/decoder

jason

jiffy

jsx

rec2json

jsone

JSON parser, streaming

jaxon

JSON validation

ejsv

jesse

JSON:API documents

jsonapi

JSONAPI.org serialization

ja_serializer

Jalaali calendar implementation

jalaali

Japanese writing systems conversion

exkanji

exromaji

Java property file reading

exjprop

Juypter kernels

jupyter

ierl

Keyword list option validator

optimal

Kubernetes Operator Development Framework

bonny

Kubernetes client

k8s

kuberl

LDAP

exldap

paddle

LRU Cache

lru_cache

LZ4 data compression

lz4_erl

Lager backend

lager_logger

Letter user avatar generation

alchemic_avatar

Lexers

lex_luthor

Licensing enumeration for project dependencies

licensir

Line segment intersection calculator

seg_seg

Load generator

ponos

Logfmt encoding/decoding

logfmt

Logger file backend

logger_file_backend

Logger for Graylog Extended Log Format (GELF)

gelf_logger

gelfx

Logging

lager

Logging framework adapter

hut

Logstash JSON formatter

logstash_logger_formatter

logstash_json

Lorem Ipsum generator

elixilorem

hemingway_lorem

MIME type extension mappins

mimetypes

MIME type parsing

mimerl

mimetype_parser

MQTT client

tortoise

Markdown parser (NIF)

cmark

Markdown parser (pure Elixir)

earmark

Markdown parser, AST based

markright

Mathematical expressions evaluator

abacus

leibniz

Mathematical helper functions

numerix

https://erlang.org/doc/man/math.html

Matrix math

matrex

Merkel map

merkle_map

Merkle hash trees

merkle_tree

Message queues framework (SQS/AMQP)

conduit

MessagePack

msgpax

Metric store

mstore

Metrics system interfaces

metrics

Mnesia clustering

mnesiac

Mnesia transactions, raft consensus (RabbitMQ)

khepri

Mobile optimized silent video conversion

silent_video

Monads

witchcraft

Money handling/storing

money

Multi-stage data ingestion/processing pipelines

broadway

Multimedia stream processing

membrane_core

Murmur3 non-cryptographic hash algorithm

murmur

Music live coding

erlang

Mutation testing

muzak

MySQL server protocol

myproto

NAT (Network Address Translation)

nat

NATS distributed messaging client

gnat

NSQ distributed messaging client

elixir_nsq

Naive Bayes string matching algorithm

simple_bayes

bayesic_nif

bayesic

Nanomsg networking client

enm

Natural language detection

paasaa

tongue

Nested data structure utilities

lens

Nested data structures at compile time

pathex

Nested map difference

map_diff

Nested map take/drop

nested_filter

Notification dispatch

ravenx

Number formats conversion, currency

number

Numeric types wrapper

numbers

OS processes/ports/command line runner

porcelain

rambo

exile

erlexec

Object Relational Mapper (ORM)

ecto

boss_db

Office documents conversion (LibreOffice)

librex

One-time passwords (OTP)

nimble_totp

pot

hotp

Onetime key-value store

onetime

OpenTelemetry tracing API

opentelemetry_api

OpenTelemetry tracing SDK

opentelemetry

OpenTracing

otter

Options validation

nimble_options

PCAP parser

expcap

PDF generator, from HTML

pdf_generator

puppeteer_pdf

PEG implementation

neotoma

PID file for UNIX

pid_file

PNG image creation

png

Pagination

scrivener

Pandoc file conversion client

pandex

panpipe

Parallel computations on collections

flow

Parallel streams

parallel_stream

Parallel worker and capacity limiting

sidejob

Parse transform utilities

parse_trans

Parser combinators

nimble_parsec

Partition tester

schism

Paseto (Platform-Agnostic Security Tokens)

paseto

Password hashing (Bcrypt)

erlpass

Password hashing (PBKDF2)

erl-pkcs5

Password hashing (argon2, bcrypt, pbkdf2_sha512)

comeonin

Password pwn check

pwned

Password strength estimation

zxcvbn

Payment processing (Stripe)

stripity_stripe

Petri nets

gen_pnet

Phone number parser

phone

ex_phone_number

Pop3 email client including attachments

pop3mail

erlpop

pop3client

PortAudio bindings

erlaudio

PostgreSQL driver

postgrex

pgo

epgsql

PostgreSQL migrations

pgsql_migration

Pre-signed URLs for client-side uploading

transmit

Priority queue

pqueue

Process custom parenting

parent

Process registry, distributed

swarm

syn

Producer/consumer pipelines with back-pressure

gen_stage

Profanity filter

expletive

Project configuration

config_smuggler

Prometheus client

prometheus

Prometheus process metrics exporter

prometheus_process_collector

Prometheus/Grafana dashboards for Elixir libs

prom_ex

Property testing

stream_data

proper

Protocol Buffers (Protobuf)

protobuf

exprotobuf

protox

enif_protobuf

Publish-Subscribe

pubsub

Push notifications (iOS/Android)

pigeon

QR code generator

eqrcode

Query string encoding

uri_query

Queue pooling (Sojourn-time)

sbroker

R* trees

erl-rstar

RADIUS Protocol

elixir_radius

radierl

eradius

RDF data model

rdf

RDF support for JSON-LD

json_ld

REPL development, auto test runner

cortex

REST API framework

rest

leptus

REST API testing

efrisby

RSASSA-PSS crypto algorithm

crypto_rsassa_pss

RSS feed parser, Rust NIF wrapper

fast_rss

RSS/ATOM feed builder (RFC4287)

atomex

RSS/ATOM feed parser

elixir_feed_parser

feeder

RabbitMQ client

amqp

rabbit

rabbit_mq

mqs

RabbitMQ producers/consumers

gen_rmq

rbmq

Random Base64 strings generator

secure_random

Random Number Generation (RNG)

https://erlang.org/doc/man/rand.html

quickrand

Random words generator

random_words

Rate-limiter

hammer

ex_rated

ratx

lambda_throttle

Rational numbers

ratio

React server-side rendering (SSR)

reaxt

react_render

Redis client

redix

eredis

Redis client (cluster mode)

eredis_cluster

Redis pooling/sharding

redis_z

Release configuration

conform

Release packaging

Mix.Tasks.Release

distillery

Releases (Debian, RPM)

distillery_packager

Releases with hot-code upgrades

edeliver

Repeating dates

repeatex

Resource pool

nimble_pool

Result/option monads

Riemann network monitor client

riemannx

katja

Robots.txt parser

robots

RocksDB client

rocksdb

Run command on file system change

eye_drops

Russian names inflection

petrovich_elixir

SIP protocol

sippet

ersip

SMPP 3.4 protocol

smppex

SMS client

apus

SMTP email client

mailer

SMTP server/client

gen_smtp

SOAP client

detergent

SOCKS4/SOCKS5 proxy server

tunnerl

SPARQL query language client

sparql

sparql_client

SQL queries with parameterized .sql files/YesQL

yesql

ayesql

eql

SQL query generator DSL

sql_dust

SSH helpers

sshex

SSH tasks runner

sshkit

SSL/TLS certificates, CA bundle

certifi

SSL/TLS certificates, Let’s Encrypt

site_encrypt

SSL/TLS driver

fast_tls

SSL/TLS verification

ssl_verify_fun

STUN/TURN

stun

SVG drawing

chunky_svg

Saga development

cizen

Sass

sass

Semantic versions

Version

Sentiment analysis (AFINN-165/emojis)

veritaserum

Set associative map for key lists

keys1value

Shell/system calls

erlsh

Short-lived keys checking

locker

SipHash algorithm

siphash

Sitemap generator

sitemapper

Slug generator

slugify

Snappy compression

esnappy

Socket wrapping

socket

Spell checker (English)

sheldon

Sphinx full text search client

giza_sphinxsearch

sphinxsearch_giza

Spinlocks

sleeplocks

Standard Library

Elixir Standard Library

https://erlang.org/doc/apps/stdlib/index.html

State machines

states_language

gearbox

machinist

Static site generator

tableau

serum

Static site generator, blog engine

blogit

Statistical functions

statistics

Statsd metrics

instruments

Stock market trading client

tai

Stream processor

swirl

String case conversion

recase

TCP network resiliency tester, Toxiproxy

toxiproxy_ex

TCP socket acceptor pool

ranch

TCP sockets

sockerl

TOML

toml

Tasks progress tracking

ex_progress

Tel URI parser (RFC3966)

ex_rfc3966

Telemetry polling

telemetry_poller

Telemetry/metrics/instrumentation

telemetry

telemetria

Telemtry metrics interface

telemetry_metrics

Telephone numbers

phone

Template language (Django)

template_compiler

erlydtl

Template language (Mustache)

mustache

bbmustache

aihtml

Temporary/burner email detector

burnex

Tensor math

Tensorflow bindings

extensor

Terminal UI (TUI), Command-line interface (CLI) kit

ratatouille

Test coverage reports

excoveralls

Test framework, Behavioral Driven Design (BDD)

espec

Test mocks

hammox

mox

mockery

mecks_unit

meck

Testing framework

ExUnit

Testing stubs

double

Testing, HTTP request mocks

bookish_spork

Testing, HTTP request/response faker

fake_server

Testing, feature/browser

wallaby

Testing, parameterized

ex_parameterized

Testing, story based

white_bread

Testing, trace-based

snabbkaffe

Tests auto run on file save

mix_test_watch

Thrift protocol for service RPC

https://thrift.apache.org/lib/erl

thrift_protocol

Thumbnails for image/video screenshots

thumbnex

Time periods and business calendars

tempus

Time periods/slots

tempus

Time zone conversion

qdate_localtime

Time zone lookup by geo coordinates

wheretz

Timezone database

tzdata

Tiny Encryption Algorithm (TEA)

tea_crypto

Tor client

torex

Tracing and debugging

exrun

recon

redbug

Tracing, platform-agnostic

spandex

Tracing/profiling

looking_glass

Tracing/stats collection

opencensus

Transactions, distributed

sage

Trie data structure

trie

U2F (Universal Second Factor)

u2f_ex

UK postcode parsing/validation

uk_postcode

URI template processor (RFC6570 compliant)

uri_template

URL referer parsing

ref_inspector

URL slugs

slugger

URL wildcard matching

fuzzyurl

URL-friendly unique ID generator

nanoid

UUID (URL-safe)

shortuuid

UUID generator

elixir_uuid

uuid_erl

Units converter

ex_uc

User agent parser

ua_inspector

Utility functions library

uef-lib

Validation, schemas

liver

Vectors/matrices/tensors

tensor

Videogame Artificial Intelligence (AI)

alex

Virtual DOM diff/patching

texas

Virtualization, libvirt

verx

erlang-libvirt

Web and RSS/Atom scraping

scrape

Web app framework

phoenix

nitro

ChicagoBoss

nova

zotonic

webmachine

Web app framework, micro

axiom

Web application monitoring

komachi_heartbeat

Web crawler/scraper

crawler

crawly

Web server

cowboy

yaws

mochiweb

Web server interface/Web application middleware

plug

raxx

simple_bridge

Web server, HTTP APIs

elli

WebDriver client

web_driver_client

WebSocket client

websockex

websocket_client

Word inflector

inflex

Word stemming, English (Porter2)

stemmer

Worker process pooling

poolboy

pooler

worker_pool

taskforce

Worker process pooling and job queue

honeydew

X.509 certificates and Certificate Signing Requests (CSRs)

x509

XLSX (Excel) file reader

xlsx_reader

XLSX files

elixlsx

xlsxir

XML builder

xml_builder

XML decode

elixir_xml_to_map

XML encode/decode

saxy

erlsom

fast_xml

XML query

sweet_xml

XML-RPC encode/decode

xmlrpc

XMPP client

romeo

xmpp

XMPP messaging platform

ejabberd

XOR filters

exor_filter

XQuery

xqerl

YAML encoder

ymlr

YAML parser

fast_yaml

yamerl

ZeroMQ

chumak

Zip file streaming

packmatic

Zipper data structure traversal

zipper

common_test utilities

katana_test

etcd client

eetcd

gRPC

grpc

grpcbox

printf/sprintf string formatting

exprintf

syslog(3) port driver

syslog

systemd integration

systemd

Plug

API Authentication framework

access_pass

API toolkit

plexy

API versioning

multiverse

versionary

AWS Signature V4

sigaws

Access logs

plug_accesslog

Authentication framework

pow

Authentication, OAuth 2.0 (multi-provider), works with Guardian

ueberauth

Authentication, OAuth 2.0/1.0 (multi-provider), works with Pow

pow_assent

Authentication, SAML 2.0 SSO (Single-Sign-On)

samly

Authentication, token-based (JWT/other), Plug/non-Plug

guardian

Authorization

canada

dictator

Block/throttle abusive requests

plug_attack

CORS headers

cors_plug

corsica

Canonical hosts

plug_canonical_host

EEx templates safe content embedding

eex_html

ETags

etag_plug

HTTP headers manipulation

cowlib

HTTP/JSON error payloads

explode

Health checks

plug_checkup

Heartbeat requests

plug_heartbeat

IP geolocation

geoip

IP geolocation, MaxMind GeoIP2

geolix

locus

IPFS libp2p swarms

erlang-libp2p

JSON API key conversion

accent

Kubernetes health checks

healthchex

Logging (plain text/JSON)

logster

Mock HTTP server

bypass

Monitoring system (Prometheus)

prometheus_plugs

OpenAPI/Swagger specification

open_api_spex

OpenAPI/Swagger/Blueprint documentation generator

xcribe

Pagination HTML output

scrivener_html

REST

plug_rest

Rails session store support

plug_rails_cookie_session_store

Secure HTTP headers

plug_secex

Server-Sent Events (SSE)

sse

Statsd metrics

plug_statsd

statsderl

Test mock HTTP server

bypass

Phoenix

API documentation generator

bureaucrat

API specification (Swagger/OpenAPI)

phoenix_swagger

Admin interface

kaffy

Admin interface for Ecto schemas

adminable

Admin interface scaffolds

torch

Asset pipeline (Webpack)

phoenix_assets_webpack

Authentication generator

mix_phx_gen_auth

Authentication, OpenID Connect client

plugoid

Authorization

bodyguard

permit

CRUD for Phoenix contexts and Absinthe

crudry

Dashboard, performance monitoring and debugging

phoenix_live_dashboard

Ecto integration

phoenix_ecto

Email

phoenix_swoosh

HTML helpers

phoenix_html

HTML sanitizer

phoenix_html_sanitizer

Integration/browser testing

phoenix_integration

Live-reload

phoenix_live_reload

LiveView component library

surface

Meta tags

phoenix_meta_tags

Metrics/Instrumentation (Prometheus)

prometheus_phoenix

Presence tracking

Phoenix.Tracker

Query params scopes/filtering

filterable

React.js component helpers (Harmonium)

harmonium

React.js components

react_phoenix

Reactive UI

phoenix_live_view

drab

Redis PubSub adapter

phoenix_pubsub_redis

SSL client authentication

phoenix_client_ssl

Search, sort and paginate

rummage_phoenix

Security static analysis

sobelow

Slim templates

phoenix_slime

Specs/Behavior Driven Development (BDD)

espec_phoenix

UI Components

harmonium

Absinthe

Absinthe GraphQL framework

absinthe

Authorization middleware

speakeasy

Batch data loading

dataloader

Plug integration

absinthe_plug

Schema testing

wormwood

Ecto

Background jobs, PostgreSQL

oban

ecto_job

Base62-encoded UUIDs

base62_uuid_field

Cassandra DB adapter

ecto_cassandra

Composable query builder

plasm

Database migrations linter [ex],

[ex],">

excellent_migrations

[ex],">

strong_migrations

Database multitenancy (PostgreSQL)

triplex

Encrypted password (Comeonin)

comeonin_ecto_password

Encryption

cloak_ecto

Enums

Ecto.Enum

Explain function

ecto_explain

Filtering

filtrex

Finite State Machine (FSM)

fsmx

Helper functions

ecto_extras

Instrumenter for Prometheus

prometheus_ecto

LDAP adapter

ecto_ldap

MSSQL/TDS adapter

tds_ecto

Mac address/network extensions (PostgreSQL)

ecto_network

Markdown query results

tabula

Mnesia adapter

ecto_mnesia

Pagination (cursor-based)

ecto_paging

paginator

Parameter validation/casting

params

PostgreSQL ISN types

isn

PostgreSQL performance insights

ecto_psql_extras

RDF graph data mapper

grax

SQLite3 adapter

sqlite_ecto

Schema structs

ecto_factory

Search, sort, and pagination

rummage_ecto

ShortUUID

ecto_shortuuid

Slugs

ecto_autoslug_field

Tenancy

ecto_tenancy_enforcer

Test fixtures/factories

ex_machina

Timex support

timex_ecto

Transform request params to query expressions

ecto_filters

Tree structures, ltree (Postgres)

hierarch

Versioning

paper_trail

Nerves

Character matrix LCD displays

ex_lcd

Cloud provider (Vultr) Nerves adapter

nerves_system_vultr

E-ink displays

inky

Embedded firmware updates

nerves_hub

Embedded software framework

nerves

Firmware framework

nerves

WPA client

nerves_wpa_supplicant

Tooling

BEAM process visualizer, GUI

visualixir

BEAM process visualizer, command line

observer_cli

Code formatter

Mix.Tasks.Format

steamroller

rebar3_format

erlfmt

http://erlang.org/doc/man/erl_tidy.html

Compile dependency visualization

dep_viz

Compile to executable binary

bakeware

Dialyzer Mix tasks

dialyxir

Docker Alpine image, Elixir/Phoenix

alpine-phoenix-builder

Documentation coverage reports

doctor

inch_ex

Documentation generation

ex_doc

EEx template formatter

prettier-plugin-eex

Eex to Heex converter

eextoheex

Elixir package security advisories

elixir-security-advisories

Emacs Erlang IDE

distel

Emacs mode for Elixir

emacs-elixir

Erlang shell, colorized

kjell

Erlang system graphs

grapherl

Flame graph profiler

eflame

Heroku buildpack for Elixir

heroku-buildpack-elixir

heroku-buildpack-elixir-otp-builds

IntelliJ plugin

intellij-elixir

Language server

elixir-ls

erlang_ls

sourcer

Nova syntax highlighting

elixir.novaextension

Oh-my-zsh plugin

elixir-oh-my-zsh

Project templates

exgen

REPL terminal colors

glitz

Refactoring linter

churn

Refactoring tools (Emacs)

Wrangler

Runtime version manager

kiex

kerl

Security hardening guide

https://erlef.github.io/security-wg/secure_coding_and_deployment_hardening/

Static analysis suite, mix task

ex_check

Static analysis, additional Credo checks

nicene

Static analysis, security scan

pest

Static code analysis/Linter

credo

elvis

https://plc.inf.elte.hu/erlang/

TextMate/Sublime Text bundle for Elixir

elixir-tmbundle

Tracing/profiling GUI, Erlang/Elixir

xprof

Vim full language integration

alchemist.vim

Vim syntax highlighting

vim-elixir

Visual Studio Code (BEAM disassemberly/bytecode viewer)

Valentin.beamdasm

Visual Studio Code (EEx snippets)

stefanjarina.vscode-eex-snippets

Visual Studio Code (EEx template formatter)

ouven.vscode-yab-for-eex-leex

Visual Studio Code (Erlang formatter)

szTheory.erlang-formatter

Visual Studio Code (Hex package info)

szTheory.hex-lens

Visual Studio Code (Hex package version intellisense)

benvp.vscode-hex-pm-intellisense

Visual Studio Code (Hex.pm version intellisense)

benvp.vscode-hex-pm-intellisense

Visual Studio Code (Language server support)

JakeBecker.elixir-ls

erlang-ls.erlang-ls

yuce.erlang-otp

pgourlain.erlang

Visual Studio Code (Linter with Credo)

iampeterbanjo.elixirlinter

Visual Studio Code (Phoenix HEEX/PETAL snippets)

PetalFramework.vscode-petal-components-snippets&ssr=false#overview

Visual Studio Code (Test runner, jump to test)

samuel-pordeus.elixir-test

Database (non-Ecto)

Apache Druid database client

panoramix

Cassandra database driver

xandra

erlcass

Cayley database driver

caylir

Clickhouse OLAP database client

pillar

Event store, PostgreSQL

eventstore

EventStore database client

extreme

InfluxDB driver

instream

influx_udp

Kafka client

kafka_ex

brod

erlkaf

Kafka data processing

broadway_kafka

Kafka microservices toolkit

kaufmann_ex

LevelDB client

exleveldb

eleveldb

MSSQL/TDS database driver

tds

MariaDB/MySQL driver

mariaex

Mnesia database client

memento

amnesia

MongoDB database driver

mongodb

mongo

mongodb_driver

MySQL/MariaDB database driver

myxql

mysql

Neo4j driver

bolt_sips

neo4j_sips_models

Oracle database driver

jamdb_oracle

RethinkDB client

rethinkdb

erlang_rethinkdb

Riak distributed database client

riak

riakc

SQLite3 database adapter

sqlitex

esqlite

Cowboy

Authentication, OpenID Connect

oidcc_cowboy

Routing improvements

trails

Server-sent events (SSE) handler

lasse

Swagger/OpenAPI integration

cowboy_swagger

Telemetry

cowboy_telemetry

Erlang Specific

2-way maps

key2value

Abstract Term database client

kvs

Build system

rebar3

erlang.mk

mad

Cache compiler

foil

Dead code remover

rebar3_hank

Documentation in the shell

docsh

Embedded BEAM for ESP32/STM32 microcontrollers

AtomVM

Erlang Term Storage (ETS) table sharding

shards

Erlang distribution, zero dependencies (for RabbitMQ)

erlang-rpm

Erlang port driver, C/C++

GEPD

Erlang terms memory size instrumentation

erlang_term

Extended standard libraries

erlware_commons

File system listener

Instrumentation/metrics

elixometer

exometer_core

Kill zombie OS processes

muontrap

Mix task helpers

mix_erlang_tasks

Model checker/Formal proofs of correctness

concuerror

McErlang

Modules string eval

dynamic_compile

Node failure detection

aten

Node monitoring

entop

OTP release compatibility detecter

geas

OpenEmbedded/Yocto build system

meta-erlang

Performance monitoring GUI

erlangpl

Ports connection with Python/Ruby

export

erlport

Pre-processor

aleppo

Process buffers

pobox

Process info

https://erlang.org/doc/man/etop.html

Python Erlang node

Pyrlang

Release assembler

relx

Release management

https://erlang.org/doc/man/reltool.html

Release management utilities

reltool_util

Testing utilities

katana_test

Tracing and debugging (GUI)

erlyberly

Type system

http://erlang.org/doc/apps/dialyzer/dialyzer_chapter.html

pure

Type system, gradual

Gradualizer

Unicode backward compatibility

unicode_util_compat

VM metrics

vmstats

Xref runner

xref_runner

Rebar

.dia file compiler

rebar3_diameter_compiler

ASN.1 module compiler

rebar3_asn1_compiler

Auto compile/reload on file change

rebar3_auto

Elixir dependency build with Mix

rebar_mix

Erlang IDL file compiler

rebar3_idl_compiler

Erlang QuickCheck properties support

rebar3_eqc

ExUnit tests

rebar3_exunit

Hex.pm plugin

rebar3_hex

Live

rebar3_live

Packrat parser-generator for PEG (Parsing Expression Grammar)

rebar3_neotoma_plugin

Port compiler

port_compiler

Protobuf compiler

rebar3_gpb_plugin

Protobuffs

rebar3_protobuffs

Release upgrades

rebar3_appup_plugin

Releases

rebar3_run

abnfc compiler

rebar3_abnfc_plugin

yang compiler

rebar3_yang_plugin

Languages Integration

BEAM implementation, Rust

lumen

C# client for Phoenix Channels

PhoenixSharp

CMake integration with Mix

elixir-cmake

Clojure JInterface integration

jiface

Clojure integration

clojang

Crystal client for Phoenix Channels

phoenix.cr

ERTS emulation in PureScript

erlps-core

Elixir to Javascript transpiler

elixir_script

Elm to Elixir compiler

elchemy

Erlang Term Storage (ETS) encode/decode, Python/JavaScript

erlpack

Erlang cluster integration, Go

ergo

Erlang struct and error message convert to Elixir

erlex

Erlang to Elixir transpiler

efe

Gleam integration with Elixir

mix_gleam

Haskell to BEAM compiler

codec-beam

Javascript AST parser

estree

Javascript Erlang term encode/decode

jem.js

NIF (C++)

nifpp

NIF (Haskell)

hsnif

NIF (Nim)

nimler

NIF (Rust)

rustler

erlang_nif-sys

NIF (SQLite)

esqlite

NIF (WASM)

wasmex

NIF (Zig)

zigler

Node.js function calls

nodejs

PHP interpreter

ephp

Port Wrapper forwarding

exos

Ruby Marshal format

ex_marshal

Rust communication with Erlang nodes

erl_dist