Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

awesome-elixir

A curated list of amazingly awesome Elixir and Erlang libraries, resources and shiny things. Updates:
https://github.com/h4cc/awesome-elixir

Last synced: 3 days ago
JSON representation

  • Miscellaneous

    • reprise - Simplified module reloader for Elixir.
    • notifier - A pluggable architecture for desktop notifications.
    • AtomVM - AtomVM allows to run Elixir/Erlang code on embedded devices such as ESP32 and STM32 microcontrollers.
    • codec-beam - Generate Erlang VM byte code from Haskell.
    • ecto_autoslug_field - Automatically creates slugs for your Ecto models.
    • elixir-browser - Browser detection for Elixir.
    • ex_phone_number - Format, normalize, and validate phone numbers.
    • address_us - Library for parsing US Addresses into their individual parts.
    • AlloyCI - AlloyCI is a Continuous Integration, Deployment, and Delivery coordinator, written in Elixir, that takes advantage of the GitLab CI Runner, and its capabilities as executor, to prepare and run your pipelines.
    • Apex - Awesome Print for Elixir.
    • AtomVM - AtomVM allows to run Elixir/Erlang code on embedded devices such as ESP32 and STM32 microcontrollers.
    • bupe - EPUB Generator and Parser.
    • charm - Use ANSI terminal characters to write colors and cursor positions.
    • codec-beam - Generate Erlang VM byte code from Haskell.
    • Countries - Countries is a collection of all sorts of useful information for every country in the ISO 3166 standard.
    • countriex - A pure elixir country data provider containing various information for every country in ISO 3166.
    • cubdb - CubDB is an embedded key-value database, written in the Elixir language. It runs locally, it is schema-less, and backed by a single file.
    • dye - A library for dyeing your terminal output.
    • dynamic_compile - Compile and load Erlang modules from string input.
    • ecto_autoslug_field - Automatically creates slugs for your Ecto models.
    • egaugex - Client to fetch and parse realtime data from egauge devices.
    • elixir-browser - Browser detection for Elixir.
    • epub_cover_extractor - Extract cover from EPUB files.
    • erlang_term - Provide the in-memory size of Erlang terms, ignoring where these are stored.
    • ex2ms - Translates Elixir functions to match specifications for use with `ets`.
    • ex_azure_speech - An Elixir SDK implementation for the Microsoft Azure Speech Service.
    • ex_phone_number - Format, normalize, and validate phone numbers.
    • ex_rated - Simple and flexible rate-limiting for API's or anything.
    • exfcm - Simple wrapper for posting Firebase Cloud Messages.
    • exisbn - ISBN validation and formatting library.
    • exldap - A module for working with LDAP from Elixir.
    • exlibris - A collection of random library functions.
    • expool - A small process pooling library for parallel tasks in Elixir.
    • exprint - A printf / sprintf library for Elixir, works as a wrapper for :io.format.
    • expyplot - Elixir interface for Plotting/Graphing library using matplotlib.pyplot.
    • exquisite - LINQ-like match_spec generation for Elixir.
    • exsync - Yet another Elixir reloader.
    • funnel - Streaming Elixir API built upon ElasticSearch's percolation.
    • gen_task - Generic Task behavior that helps to encapsulate worker errors and recover from them in classic GenStage's.
    • gimei_ex - Elixir port of gimei library.
    • growl - Simple wrapper for growl, the notification system for OSX.
    • hammer - A rate-limiter with pluggable storage backends, including Redis.
    • html_entities - Elixir module for decoding HTML entities in a string.
    • huex - Elixir client for Philips Hue connected light bulbs.
    • indicado - Technical indicator library for Elixir with no dependencies.
    • japan_municipality_key - Elixir Library for Japan municipality key converting.
    • Jisho-Elixir - An API wrapper for Jisho.org, an online Japanese dictionary. Allows users to search by word, symbol, and or tags (refer to docs).
    • keys1value - Erlang set associative map for key lists.
    • licensir - A mix task that lists the license(s) of all installed packages in your project.
    • mixgraph - An interactive dependency plotter for your Hex Package.
    • mixstar - MixStar starred GitHub repository that depends on your project.
    • netrc - Reads netrc files implemented in Elixir.
    • onetime - An onetime key-value store for Elixir.
    • pact - Better dependency injection in Elixir for cleaner code and testing.
    • passbook - Elixir library to create Apple Wallet (.pkpass) files.
    • phone - A parser to get useful info from telephone numbers.
    • porcelain - Porcelain implements a saner approach to launching and communicating with external OS processes from Elixir.
    • presentex - Elixir to HTML/JavaScript based presentation framework.
    • quarantine - Quarantine is a tiny OTP application for feature toggles.
    • ratekeeper - Rate limiter and rate-limited actions scheduler.
    • ratx - Rate limiter and overload protection for erlang application.
    • reprise - Simplified module reloader for Elixir.
    • spawndir - Spawns processes from the file system.
    • spotify_ex - An Elixir wrapper for the Spotify Web API.
    • std_json_io - Application for managing and communicating with IO servers via JSON.
    • url_unroller - Simple URL unroller (un-shortener) in Elixir.
    • vessel - Elixir MapReduce interfaces with Hadoop Streaming integration.
    • weighted_random - Weighted random picking.

  • Native Implemented Functions

    • Rustler - Library for writing NIFs for Erlang or Elixir safely in Rust. No segfaults.
    • Rustler - Library for writing NIFs for Erlang or Elixir safely in Rust. No segfaults.
    • hsnif - Tool that allows to write Erlang NIF libraries in Haskell.
    • nifty - Helper script for setting up the boilerplate required when writing a NIF.
    • Rustler - Library for writing NIFs for Erlang or Elixir safely in Rust. No segfaults.

  • Office

    • xlsxir - Xlsx file parser with support for ISO 8601 date formats. Data is extracted to an Erlang Term Storage (ETS) table and is accessed through various functions.
    • elixlsx - A writer for XLSX files.
    • excellent - An OpenXL (Excel 2000) Parser for Elixir.
    • xlsxir - Xlsx file parser with support for ISO 8601 date formats. Data is extracted to an Erlang Term Storage (ETS) table and is accessed through various functions.

  • Algorithms and Data structures

    • data_morph - Create Elixir structs from data.
    • monad - Haskell inspired monads in Elixir stylish syntax.
    • eastar - A* graph pathfinding in pure Elixir.
    • exfsm - Simple elixir library to define a static FSM.
    • red_black_tree - Red-Black tree implementation in Elixir.
    • sorted_set - Sorted Sets for Elixir.
    • witchcraft - Common algebraic structures and functions for Elixir.
    • aja - High performance persistent vectors and ordered maps.
    • array - An Elixir wrapper library for Erlang's array.
    • aruspex - Aruspex is a configurable constraint solver, written purely in Elixir.
    • bimap - Pure Elixir implementation of [bidirectional maps](https://en.wikipedia.org/wiki/Bidirectional_map) and multimaps.
    • bitmap - Pure Elixir implementation of [bitmaps](https://en.wikipedia.org/wiki/Bitmap).
    • blocking_queue - BlockingQueue is a simple queue implemented as a GenServer. It has a fixed maximum length established when it is created.
    • bloomex - A pure Elixir implementation of Scalable Bloom Filters.
    • clope - Elixir implementation of CLOPE: A Fast and Effective Clustering Algorithm for Transactional Data.
    • Closure Table - Closure Table for Elixir - a simple solution for storing and manipulating complex hierarchies. It provides in-memory and Ecto adapters.
    • combination - Elixir library to generate combinations and permutations from Enumerable collection.
    • conrex - An Elixir implementation of the CONREC algorithm for topographic or isochrone maps.
    • count_buffer - Buffer a large set of counters and flush periodically.
    • cuckoo - A pure Elixir implementation of [Cuckoo Filters](https://www.cs.cmu.edu/%7Edga/papers/cuckoo-conext2014.pdf).
    • cuid - Collision-resistant ids optimized for horizontal scaling and sequential lookup performance, written in Elixir.
    • dataframe - Package providing functionality similar to Python's Pandas or R's data.frame().
    • datastructures - A collection of protocols, implementations and wrappers to work with data structures.
    • def_memo - A memoization macro (defmemo) for elixir using a genserver backing store.
    • dlist - Deque implementations in Elixir.
    • eastar - A* graph pathfinding in pure Elixir.
    • ecto_materialized_path - Tree structure, hierarchy and ancestry for the ecto models.
    • ecto_state_machine - Finite state machine pattern implemented on Elixir and adopted for Ecto.
    • elistrix - A latency / fault tolerance library to help isolate your applications from an uncertain world of slow or failed services.
    • emel - A simple and functional machine learning library written in elixir.
    • erlang-algorithms - Implementations of popular data structures and algorithms.
    • exconstructor - An Elixir library for generating struct constructors that handle external data with ease.
    • exfsm - Simple elixir library to define a static FSM.
    • exkad - A [kademlia](https://en.wikipedia.org/wiki/Kademlia) implementation in Elixir.
    • exmatrix - ExMatrix is a small library for working with matrices, originally developed for testing matrix multiplication in parallel.
    • exor_filter - Nif for xor_filters. 'Faster and Smaller Than Bloom and Cuckoo Filters'.
    • ezcryptex - Thin layer on top of Cryptex.
    • flow - Computational parallel flows on top of GenStage.
    • fsm - Finite state machine as a functional data structure.
    • fuse - This application implements a so-called circuit-breaker for Erlang.
    • gen_fsm - A generic finite state-machine - Elixir wrapper around OTP's gen_fsm.
    • graphex - A library for composing and executing task graphs in elixir.
    • graphmath - An Elixir library for performing 2D and 3D mathematics.
    • hash_ring_ex - A consistent hash-ring implementation for Elixir.
    • hypex - Fast Elixir implementation of HyperLogLog.
    • indifferent - Indifferent access for Elixir maps/list/tuples with custom key conversion.
    • isaac - Isaac is an elixir module for ISAAC: a fast cryptographic random number generator.
    • jumper - Jump consistent hash implementation in Elixir (without NIFs).
    • key2value - Erlang 2-way Set Associative Map.
    • lfsr - Elixir implementation of a binary Galois Linear Feedback Shift Register.
    • loom - A CRDT library with δ-CRDT support.
    • luhn - Luhn algorithm in Elixir.
    • lz4 - LZ4 bindings for Erlang for fast data compressing.
    • machinery - A state machine library for structs in general, it integrates with Phoenix out of the box.
    • mason - Coerce maps into structs. This is helpful e.g. when you interface a REST API and want to create a struct from the response.
    • matrex - A blazing fast matrix library for Elixir/Erlang with C implementation using CBLAS.
    • merkle_tree - A Merkle hash tree implementation in Elixir.
    • minmaxlist - Elixir library extending `Enum.min_by/2`, `Enum.max_by/2` and `Enum.min_max_by/2` to return a list of results instead of just one.
    • mmath - A library for performing math on number 'arrays' in binaries.
    • monadex - Upgrade your Elixir pipelines with monads.
    • murmur - A pure Elixir implementation of the non-cryptographic hash Murmur3.
    • nary_tree - An Elixir implementation of generic n-ary tree data structure.
    • natural_sort - Elixir natural sort implementation for lists of strings.
    • navigation_tree - A navigation tree representation with helpers to generate HTML out of it.
    • parallel_stream - A parallel stream implementation for Elixir.
    • paratize - Elixir library providing some handy parallel processing (execution) facilities that support configuring number of workers and timeout.
    • parex - Parallel Execute (Parex) is an Elixir module for executing multiple (slow) processes in parallel.
    • qcomplex - Elixir library implementing complex numbers and math operations for them.
    • qex - Wraps `:queue`, with improved API and `Inspect`, `Collectable` and `Enumerable` protocol implementations.
    • qrational - Elixir library implementing rational numbers and math operations for them.
    • ratio - Adds Rational Numbers and allows them to be used in common arithmetic operations. Also supports conversion between Floats and Rational Numbers.
    • red_black_tree - Red-Black tree implementation in Elixir.
    • remodel - An Elixir presenter package used to transform map structures.
    • rendezvous - Implementation of the Rendezvous or Highest Random Weight (HRW) hashing algorithm in Elixir.
    • rock - Elixir implementation of ROCK: A Robust Clustering Algorithm for Categorical Attributes.
    • simhash - Simhash implementation using Siphash and N-grams.
    • sleeplocks - BEAM friendly spinlocks for Elixir/Erlang.
    • sorted_set - Sorted Sets for Elixir.
    • spacesaving - stream count distinct element estimation using the "space saving" algorithm.
    • structurez - A playground for data structures in Elixir.
    • supermemo - An Elixir implementation of the [Supermemo 2 algorithm](https://www.supermemo.com/english/ol/sm2.htm).
    • tfidf - An Elixir implementation of term frequency–inverse document frequency.
    • the_fuzz - Fuzzy string-matching algorithm implementations.
    • trie - Erlang Trie Implementation.
    • zipper_tree - Variadic arity tree with a zipper for Elixir.
    • sfmt - SIMD-oriented Fast Mersenne Twister (SFMT) for Erlang.
    • tinymt - Tiny Mersenne Twister (TinyMT) for Erlang.
    • fnv - Pure Elixir implementation of Fowler–Noll–Vo hash functions.

  • Artificial Intelligence

    • Runhyve - Runhyve is complete virtual machines manager for bhyve on FreeBSD. It's written in Elixir and uses Phoenix framework.
    • Runhyve - Runhyve is complete virtual machines manager for bhyve on FreeBSD. It's written in Elixir and uses Phoenix framework.
    • Axon - Nx-powered Neural Networks.
    • Beaver - Beaver is a LLVM/MLIR Toolkit in Elixir and Zig.
    • ExLLama - LlamaCpp Nif Extensions for Elixir/Erlang. ([Docs](https://hexdocs.pm/ex_llama/ExLLama.html)).
    • Exnn - Evolutive Neural Networks framework à la G.Sher written in Elixir. ([Docs](http://zampino.github.io/exnn/)).
    • GenAI - An extensible Generative AI Completion API Wrapper with basic chat completion with tool use support provided for Gemini, Anthropic, OpenAI, and Mistral models. ([Docs](https://hexdocs.pm/genai/GenAI.html)).
    • m2cgen - A CLI tool to transpile trained classic ML models into a native Elixir code with zero dependencies.
    • Neat-Ex - An Elixir implementation of the NEAT algorithm. ([Docs](https://hexdocs.pm/neat_ex/Neat.html)).
    • Noizu-OpenAi - An Elixir Api for the OpenAI Library. ([Docs](https://hexdocs.pm/noizu_labs_open_ai/api-reference.html)).
    • Nx - Multi-dimensional arrays (tensors) and numerical definitions for Elixir.
    • simple_bayes - A Simple Bayes / Naive Bayes implementation in Elixir.
    • Synapses - A lightweight library for neural networks.
    • Noizu-OpenAi - An Elixir Api for the OpenAI Library. ([Docs](https://hexdocs.pm/noizu_labs_open_ai/api-reference.html)).
    • Weaviate - Weaviate client and macros for declaring records. ([Docs](https://hexdocs.pm/noizu_weaviate/api-reference.html)).

  • Authentication

    • ueberauth_auth0 - An Ueberauth strategy for using Auth0 to authenticate your users.
    • apache_passwd_md5 - Apache/APR Style Password Hashing.
    • basic_auth - Elixir Plug to easily add HTTP basic authentication to an app.
    • github_oauth - A simple github oauth library.
    • htpasswd - Apache htpasswd file reader/writer in Elixir.
    • oauth2 - An OAuth 2.0 client library for Elixir.
    • pow - Robust, modular, and extendable user authentication system ([Website](https://powauth.com) - [Doc](https://hex.pm/packages/pow)).
    • ueberauth_vk - [vk.com](https://vk.com) Strategy for Überauth.
    • aeacus - A simple configurable identity/password authentication module (Compatible with Ecto/Phoenix).
    • apache_passwd_md5 - Apache/APR Style Password Hashing.
    • aws_auth - AWS Signature Version 4 Signing Library for Elixir.
    • basic_auth - Elixir Plug to easily add HTTP basic authentication to an app.
    • coherence - Coherence is a full featured, configurable authentication system for Phoenix. ([Docs](https://hexdocs.pm/coherence/Coherence.html)).
    • doorman - Tools to make Elixir authentication simple and flexible.
    • elixir_auth_google - The simplest way to add Google OAuth authentication ("Sign in with Google") to your Elixir/Phoenix app.
    • ex_aws_msk_iam_auth - AWS Managed Streaming for Apache Kafka (MSK) IAM Authentication plugin for Broadway Kafka.
    • github_oauth - A simple github oauth library.
    • goth - OAuth 2.0 library for server to server applications via Google Cloud APIs.
    • guardian - An authentication framework for use with Elixir applications. ([Docs](https://hexdocs.pm/guardian/Guardian.html)).
    • guardian_db - An extension to Guardian that tracks tokens in your application's database to prevent playback. ([Docs](https://hexdocs.pm/guardian_db/readme.html)).
    • guardian_redis - Redis repository for Guardian DB. ([Docs](https://hexdocs.pm/guardian_redis/readme.html)).
    • htpasswd - Apache htpasswd file reader/writer in Elixir.
    • mojoauth - MojoAuth implementation in Elixir.
    • oauth2_facebook - A Facebook OAuth2 Provider for Elixir.
    • oauth2_github - A GitHub OAuth2 Provider for Elixir.
    • oauth2cli - Simple OAuth2 client written for Elixir.
    • oauth2ex - Another OAuth 2.0 client library for Elixir.
    • oauther - An OAuth 1.0 implementation for Elixir.
    • passwordless_auth - Simple passwordless login or 2-factor / multi-factor authentication for Elixir.
    • phauxth - Authentication library for Phoenix 1.3 and other Plug-based apps.
    • phoenix_client_ssl - Client SSL Authentication Plugs for Phoenix and other Plug-based apps.
    • phx_gen_auth - An authentication system generator for Phoenix 1.5 applications.
    • samly - SAML SP SSO made easy ([Doc](https://hexdocs.pm/samly/readme.html)).
    • sesamex - Another simple and flexible authentication solution in 5 minutes!.
    • sigaws - AWS Signature V4 signing and verification library ([Doc](https://hexdocs.pm/sigaws/Sigaws.html)).
    • ueberauth - An Elixir Authentication System for Plug-based Web Applications.
    • ueberauth_cas - Central Authentication Service strategy for Überauth.
    • ueberauth_github - A GitHub strategy for Überauth.
    • ueberauth_google - A Google strategy for Überauth.
    • ueberauth_identity - A simple username/password strategy for Überauth.
    • ueberauth_line - LINE Strategy for Überauth.
    • ueberauth_microsoft - A Microsoft strategy for Überauth.
    • ueberauth_slack - A Slack strategy for Überauth.
    • ueberauth_twitter - Twitter Strategy for Überauth.
    • ueberauth_weibo - [Weibo](https://weibo.com) OAuth2 Strategy for Überauth.
    • zachaeus - An easy to use licensing system, based on asymmetric cryptography.
    • pow - Robust, modular, and extendable user authentication system ([Website](https://powauth.com) - [Doc](https://hex.pm/packages/pow)).
    • ueberauth_facebook - Facebook OAuth2 Strategy for Überauth.
    • ueberauth_foursquare - Foursquare OAuth2 Strategy for Überauth.

  • Cloud Infrastructure and Management

    • Cloudi - CloudI is for back-end server processing tasks that require soft-realtime transaction.
    • ex_aws - AWS client, supporting Dynamo, Kinesis, Lambda, SQS, and S3.
    • aws - AWS clients for Elixir.
    • Bonny - Kubernetes Operator Development Framework.
    • discovery - An OTP application for auto-discovering services with Consul.
    • erlcloud - Cloud Computing library for Erlang (Amazon EC2, S3, SQS, SimpleDB, Mechanical Turk, ELB). ([Docs](https://hexdocs.pm/erlcloud/)).
    • ex_riak_cs - Riak CS API client.
    • fleet_api - A simple wrapper for the Fleet (CoreOS) API. Can be used with etcd tokens or via direct node URLs.
    • Gandi - Gandi Wrapper for Leaseweb infrastructure.
    • IElixir - Jupyter's kernel for Elixir programming language.
    • k8s - Kubernetes Elixir client with CRD support, multi-cluster support, pluggable auth, and configurable middleware.
    • Kazan - Kubernetes client for Elixir, generated from the k8s open API specifications.
    • Kubex - Kubernetes client and integration for Elixir, written in pure Elixir.
    • Leaseweb - Elixir Wrapper for Leaseweb infrastructure.
    • libcluster - Automatic cluster formation/healing for Elixir applications.([Docs](https://hexdocs.pm/libcluster/readme.html)).
    • nodefinder - Strategies for automatic node discovery in Erlang.
    • nomad - Create cloud portable Elixir and Phoenix apps. Write once, use everywhere.
    • sidejob - Parallel worker and capacity limiting library for Erlang.
    • sidetask - SideTask is an alternative to Task.Supervisor using Basho's sidejob library with parallelism and capacity limiting.
    • skycluster - Automatic Erlang cluster formation, messaging and management for Elixir/Erlang applications. Integrated with Kubernetes.
    • vercel - An Elixir wrapper for Vercel's API.

  • Code Analysis

    • DepViz - A visual tool to help developers understand Elixir recompilation in their projects. ([Code](https://github.com/axelson/dep_viz/)).
    • belvedere - An example of CircleCI integration with Elixir.
    • coverex - Coverage Reports for Elixir.
    • credo - A static code analysis tool with a focus on code consistency and teaching Elixir. ([Docs](https://hexdocs.pm/credo/Credo.html)).
    • dialyxir - Mix tasks to simplify use of Dialyzer in Elixir projects.([Docs](https://hexdocs.pm/dialyzex/Mix.Tasks.Dialyzer.html)).
    • dogma - A code style linter for Elixir, powered by shame.([Docs](https://hexdocs.pm/dogma/api-reference.html)).
    • ex_check - One task to efficiently run all code analysis & testing tools in an Elixir project.
    • excellent_migrations - Detecting potentially dangerous operations in database migrations.
    • excoveralls - Coverage report tool for Elixir with coveralls.io integration.
    • exprof - A simple code profiler for Elixir, using eprof.
    • int_set - A time- and memory-efficient unordered data structure for positive integers.

  • Command Line Applications

    • phoenix-cli - Command-line interface for Phoenix Framework like Rails commands.
    • ex_cli - User friendly CLI apps for Elixir.
    • ex_prompt - Helper package to add interactivity to your command line applications as easy as possible.
    • anubis - Command-Line application framework for Elixir.
    • elementtui - Library to help create terminal user interfaces (TUI).
    • firex - Firex is a library for automatically generating command line interfaces (CLIs) from an elixir module.
    • getopt - Command-line options parser for Erlang.
    • loki - Library for creating interactive command-line application.
    • optimus - Command-line option parser for Elixir inspired by [clap.rs](https://clap.rs/).
    • owl - Owl is a toolkit for writing command-line user interfaces in Elixir.
    • progress_bar - Command-line progress bars and spinners.
    • ratatouille - A TUI (terminal UI) kit for Elixir.
    • scribe - Pretty-print tables of Elixir structs and maps. Inspired by hirb.
    • table_rex - Generate configurable ASCII style tables for display.
    • tabula - Pretty print list of Ecto query results / maps in ascii tables (GitHub Markdown/OrgMode).

  • Date and Time

    • tiktak - Fast and lightweight web scheduler written in Elixir.
    • crontab - A Cron Expressions Parser, Composer & Date Candidate Finder.
    • block_timer - Macros to use :timer.apply_after and :timer.apply_interval with a block.
    • calendar - Calendar is a date and time library for Elixir.
    • calendarific - Calendarific is a wrapper for the holiday API Calendarific.
    • calixir - Calixir is a port of the Lisp calendar software calendrica-4.0 to Elixir.
    • chronos - An Elixir date/time library.
    • cocktail - Elixir date recurrence library based on iCalendar events.
    • cronex - Cron like system you can mount in your supervision tree.
    • emojiclock - An Elixir module for giving you an emoji clock for a given hour.
    • ex_ical - ICalendar parser.
    • filtrex - A library for performing and validating complex SQL-like filters from a client (e.g. smart filters).
    • good_times - Expressive and easy to use datetime functions.
    • jalaali - Jalaali calendar implementation for Elixir.
    • milliseconds - Simple library to work with milliseconds in Elixir.
    • moment - Parse, validate, manipulate, and display dates in Elixir.
    • open_hours - Time calculations using business hours.
    • quantum - Cron-like job scheduler for Elixir applications.
    • repeatex - Natural language parsing for repeating dates.
    • timelier - A cron-style scheduler for Elixir.
    • timex - Easy to use Date and Time modules for Elixir.
    • timex_interval - A date/time interval library for Elixir projects, based on Timex.
    • tzdata - The timezone database in Elixir.

  • Deployment

    • Gigalixir - A fully-featured PaaS designed for Elixir. Supports clustering, hot upgrades, and remote console/observer. Free to try without a credit card.
    • edeliver - Deployment for Elixir and Erlang.
    • Gigalixir - A fully-featured PaaS designed for Elixir. Supports clustering, hot upgrades, and remote console/observer. Free to try without a credit card.
    • akd - Capistrano like, Configurable, and easy to set up Elixir Deployment Automation Framework.
    • ansible-elixir-stack - 1-command setup & deploys to servers, with first-class support for Phoenix apps.
    • bootleg - Simple deployment and server automation for Elixir.
    • bottler - Bottler is a collection of tools that aims to help you generate releases, ship them to your servers, install them there, and get them live on production.
    • elixir-on-docker - A project template to get started developing clustered Elixir applications for cloud environments.
    • exdm - Deploy Elixir applications via mix tasks.
    • exreleasy - Dead simple and Mix friendly tool for releasing Elixir applications.
    • gatling - Collection of mix tasks to automatically create a exrm release from git and launch/upgrade it on your server.
    • heroku-buildpack-elixir - Heroku buildpack to deploy Elixir apps to Heroku.

  • Documentation

    • inch-ci - Documentation badges for Ruby & Elixir.
    • maru_swagger - Add swagger compliant documentation to your maru API.
    • xcribe - Generate API documentation from tests using Swagger (OpenAPI) or API Blueprint specification.
    • blue_bird - BlueBird is a library written in the Elixir programming language for the Phoenix framework. It lets you generate API documentation in the API Blueprint format from annotations in controllers and automated tests.
    • bureaucrat - Generate Phoenix API documentation from tests.
    • ex_doc - ExDoc is a tool to generate documentation for your Elixir projects.
    • ex_doc_dash - Formatter for ExDoc to generate docset documentation for use in Dash.app.
    • hexdocset - Convert hex doc to Dash.app's docset format.
    • phoenix_api_docs - Generate API Blueprint documentation from controllers and tests in the Phoenix framework.
    • phoenix_swagger - Provides swagger integration to the Phoenix framework.

  • Email

    • pop3mail - Pop3 client to download email (including attachments) from the inbox via the commandline or Elixir API.
    • bamboo - Composable, testable and adapter based email library. Out of the box support for rendering with Phoenix and a plug for previewing sent emails in dev.
    • gen_smtp - A generic Erlang SMTP server and client that can be extended via callback modules.
    • mailibex - Library containing Email-related implementations in Elixir: dkim, spf, dmark, mimemail, smtp.
    • mailman - Mailman provides a clean way of defining mailers in your Elixir applications.
    • burnex - Burner email (temporary address) detector.
    • echo - A meta-notification system; Echo checks notification preferences & dispatches notifications.
    • ex_postmark - Postmark adapter for sending template emails in Elixir.
    • gmail - A simple Gmail REST API client for Elixir.
    • mail - An RFC2822 implementation in Elixir, built for composability.
    • mailer - A simple SMTP mailer.
    • ravenx - Notification dispatch library for Elixir applications.
    • smoothie - Smoothie inline styles of your email templates, and generates a plain text version from the HTML.
    • swoosh - Compose, deliver and test your Emails (with attachments!) easily in Elixir with adapters for SMTP, Sendgrid, Mandrill, Mailgun, Postmark and lots others, plus Phoenix integration with mailbox preview.

  • Embedded Systems

    • nerves - A framework for writing embedded software in Elixir.
    • nerves - A framework for writing embedded software in Elixir.

  • Encoding and Compression

    • huffman - Huffman encoding and decoding in Elixir.
    • ex_rlp - Elixir implementation of Ethereum's RLP (Recursive Length Prefix) encoding.

  • Eventhandling

    • event_bus - Simple event bus implementation with topic filtering and built-in event store and event watcher.
    • event_bus - Simple event bus implementation with topic filtering and built-in event store and event watcher.
    • cizen - Build highly concurrent, monitorable, and extensible applications with a collection of sagas.
    • goldrush - Small, Fast event processing and monitoring for Erlang/OTP applications.
    • reaxive - Reaxive is a reactive event handling library, inspired by [Elm](http://elm-lang.org) and Reactive Extensions.
    • wait_for_it - Provides convenient and easy-to-use facilities for synchronizing concurrent activities.

  • Files and Directories

    • cassius - Monitor Linux file system events.
    • exfswatch - A file change watcher wrapper based on __fs__.
    • format_parser.ex - Elixir library to figure out the type and the format of a file.
    • fs - Erlang FileSystem Listener.
    • dir_walker - DirWalker lazily traverses one or more directory trees, depth first, returning successive file names.
    • elixgrep - A framework for doing Hadoop style Map/Reduce operations on collections of files.
    • ex_guard - ExGuard is a mix command to handle events on file system modifications.
    • ex_minimatch - Globbing paths without walking the tree!.
    • exfile - File upload handling, persistence, and processing in Elixir and Plug.
    • eye_drops - Configurable mix task to watch file changes and run the corresponding command.
    • fs - Erlang FileSystem Listener.
    • fwatch - A callback-based file watcher based on __fs__.
    • ivcu - File Validator, Converter, and Uploader.
    • librex - Elixir library to convert office documents to other formats using LibreOffice.
    • Radpath - Path library for Elixir, inspired by Python's Enhpath.
    • sentix - A cross-platform file watcher for Elixir based on fswatch.
    • sizeable - An Elixir library to make file sizes human-readable.
    • waffle - Flexible file upload and attachment library for Elixir.
    • zarex - Filename sanitization for Elixir.

  • Formulars

    • forms - Erlang Business Documents Generator.
    • forms - Erlang Business Documents Generator.

  • Framework Components

    • turn_the_page - Fast, simple and lightweight pagination system for your Elixir application.
    • commanded - Command handling middleware for Command Query Responsibility Segregation (CQRS) applications.
    • plug - A specification and conveniences for composable modules in between web applications.
    • plug_canonical_host - Plug to ensure all requests are served from a single canonical host.
    • plug_forward_peer - Very simple plug which reads X-Forwarded-For or Forwarded header according to RFC7239 and fill conn.remote_ip with the root client ip.
    • plugsnag - Bugsnag notifier for Elixir's plug.
    • rummage_ecto - A configurable framework to search, sort and paginate Ecto Queries.
    • rummage_phoenix - A support framework for searching, sorting and paginating models in Phoenix, with HTML support.
    • scrivener_headers - Helpers for paginating API responses with Scrivener and HTTP headers.
    • surface - A server-side rendering component library for Phoenix.
    • torch - Torch is a rapid admin generator for Phoenix apps. It uses generators rather than DSLs to ensure that the code remains maintainable.
    • webassembly - Web DSL for Elixir.
    • absinthe_plug - Plug support for Absinthe.
    • access pass - Authentication framework that can be used with or outside of phoenix. Similar to Addict but geared towards API usage.([Docs](https://hexdocs.pm/access_pass/api-reference.html#content)).
    • addict - User authentication for Phoenix Framework.
    • airbrake_plug - Report errors in your Plug stack or whatever to Airbrake.
    • Backpex - Highly customizable administration panel for Phoenix LiveView applications. ([Docs](https://hexdocs.pm/backpex/), [Demo](https://backpex.live/)).
    • better_params - Elixir Plug for cleaner request params in web apps.
    • blaguth - Basic Access Authentication in Plug applications.
    • cors_plug - An Elixir plug that adds CORS headers to requests and responds to preflight requests (OPTIONS).
    • corsica - Elixir library for dealing with CORS requests.
    • crudex - CRUD utilities for Phoenix and Ecto.
    • dayron - A repository _similar_ to `Ecto.Repo` that works with REST API requests instead of a database.
    • ex_admin - ExAdmin is an auto administration package for Elixir and the Phoenix Framework.
    • exdjango - A few elixir libraries for working with django.
    • exrecaptcha - Simple reCaptcha display/verify code for Elixir applications.
    • filterable - Simple query params filtering for Phoenix framework inspired by Rails has_scope.
    • graphql_parser - An Elixir binding for [libgraphqlparser](https://github.com/graphql/libgraphqlparser).
    • http_router - HTTP Router with various macros to assist in developing your application and organizing your code.
    • kerosene - Pagination for Ecto and Phoenix.
    • mellon - An authentication module for Plug applications.
    • multiverse - Plug that allows to add version compatibility layers via API Request/Response Gateways.
    • params - Use Ecto to enforce/validate parameters structure, akin to Rails' strong parameters.
    • phoenix_ecto - Phoenix and Ecto integration.
    • phoenix_haml - Phoenix Template Engine for Haml.
    • phoenix_html - Phoenix.HTML functions for working with HTML strings and templates.
    • phoenix_html_sanitizer - HTML Sanitizer integration for Phoenix.
    • phoenix_html_simplified_helpers - Some helpers for phoenix html (truncate, time_ago_in_words, number_with_delimiter).
    • phoenix_linguist - A project that integrates Phoenix with Linguist, providing a plug and view helpers. It looks abandoned: its last commit was on 2015 and its CI runs Elixir 1.0.3.
    • phoenix_live_reload - Provides live-reload functionality for Phoenix.
    • phoenix_meta_tags - Generate meta tags for a website.
    • phoenix_pubsub_postgres - Postgresql PubSub adapter for Phoenix apps.
    • phoenix_pubsub_rabbitmq - RabbitMQ adapter for Phoenix's PubSub layer.
    • phoenix_pubsub_redis - The Redis PubSub adapter for the Phoenix framework.
    • phoenix_pubsub_vernemq - The VerneMQ MQTT pubsub adapter for the Phoenix framework.
    • phoenix_slime - Slim template support for Phoenix.
    • phoenix_svg - Use inline SVGs in Phoenix.
    • phoenix_token_auth - Token authentication solution for Phoenix. Useful for APIs or single page apps.
    • phoenix_turnstile - Phoenix components and helpers for using CAPTCHAs with Cloudflare Turnstile.
    • phx_component_helpers - Extensible live_components, without boilerplate.
    • plug_accesslog - Plug for writing access logs.
    • plug_and_play - Set up a Plug application with less boilerplate.
    • plug_auth - Collection of authentication-related plugs.
    • plug_checkup - Plug for adding simple health checks to your app.
    • plug_cloudflare - Inspired by mod_cloudflare, this Elixir plug parses Cloudflares CF-Connecting-IP HTTP request header into Plug.Conn's remote_ip field.
    • plug_forward_peer - Very simple plug which reads X-Forwarded-For or Forwarded header according to RFC7239 and fill conn.remote_ip with the root client ip.
    • plug_fprof - A Plug that adds fprof tracing to requests, to allow for easy profiling.
    • plug_graphql - Phoenix Plug integration for [GraphQL Elixir](http://graphql-elixir.org/).
    • plug_heartbeat - A plug for responding to heartbeat requests.
    • plug_jwt - Plug for JWT authentication.
    • plug_password - Plug for adding simple cookie-based authentication.
    • plug_rails_cookie_session_store - Rails compatible Plug session store.
    • plug_redirect_https - Plug to redirect http requests to https requests behind a reverse proxy.
    • plug_require_header - Require and extract HTTP headers and handle missing ones.
    • plug_response_header - easy manipulation of HTTP response headers.
    • plug_ribbon - Injects a ribbon to your web application in the development environment.
    • plug_secex - Plug that adds various HTTP Headers to make Phoenix/Elixir app more secure.
    • plug_session_memcached - A very simple memcached session store for Elixir's plug.
    • plug_sigaws - AWS Signature V4 authentication protection for Phoenix/Plug Routes ([Docs](https://hexdocs.pm/plug_sigaws/PlugSigaws.html)).
    • plug_statsd - A plug for automatically sending timing and count metrics to statsd.
    • pluggable - Build `plug`-like pipelines with your own token (instead of `%Plug.Conn{}`).
    • plugs - Collection of Plug middleware for web applications.
    • plugsnag - Bugsnag notifier for Elixir's plug.
    • raygun - Capture bugs and send them to Raygun.
    • react_phoenix - Render React.js components in Phoenix views focusing on easy installation and Brunch compatibility.
    • recaptcha - A simple reCaptcha 2 library for Elixir applications.
    • resin - Resin is a plug that will add a configurable delay to every request that's passing through it, unless run in production.
    • revision_plate_ex - Plug application and middleware that serves endpoint returns application's REVISION.
    • rummage_ecto - A configurable framework to search, sort and paginate Ecto Queries.
    • scaffold - A mix task for creating new projects based on templates fetched from a Git-repo.
    • scrivener_headers - Helpers for paginating API responses with Scrivener and HTTP headers.
    • scrivener_html - Helpers built to work with Scrivener's page struct to easily build HTML output for various CSS frameworks.
    • sentinel - An authentication framework for Phoenix extending guardian with routing and other basic functionality.
    • trailing_format_plug - An Elixir plug to support legacy APIs that use a rails-like trailing format.
    • weebo - An XML-RPC parser/formatter for Elixir, with full support for datatype mapping.

  • Frameworks

    • Flowbite - An open-source UI component library built with Tailwind CSS and compatible with Phoenix/Elixir.
    • Ash Framework - A declarative, resource-oriented application framework for Elixir.
    • exelli - An Elli Elixir wrapper with some sugar syntax goodies.
    • kitto - A framework for interactive dashboards.
    • n2o - Distributed Application Server.
    • nitro - Nitrogen-compatible Web Framework.
    • Petal Components - A set of HEEX components that makes it easy for Phoenix developers to build beautiful web apps.
    • phoenix - Elixir Web Framework targeting full-featured, fault tolerant applications with realtime functionality.
    • placid - A REST toolkit for building highly-scalable and fault-tolerant HTTP APIs with Elixir.
    • rackla - API Gateways in Elixir.
    • relax - Simple Elixir implementation of a [jsonapi.org](http://jsonapi.org) server.
    • rest - Micro-REST framework with typed JSON.
    • RIG - Create low-latency, interactive user experiences for stateless microservices.
    • sugar - Modular web framework for Elixir.
    • trot - An Elixir web micro-framework.

  • Games

    • ECSx - An Entity-Component-System framework providing a battle ship game as a tutorial ([read more on Dockyard blog](https://dockyard.com/blog/2023/07/06/ecsx-a-new-approach-to-game-development-in-elixir)).
    • mines - A minesweeper clone in the terminal.
    • Binbo - A chess representation written in Erlang using [Bitboards](https://www.chessprogramming.org/Bitboards), ready for use on game servers.
    • entice - A distributed Entity-Component-System framework, providing its own example MMORPG server.
    • pictionary - A multiplayer guessing and drawing game ([skribbl.io](https://skribbl.io/) clone).
    • rayex - Raylib bindings to Elixir for games programming.
    • Rovex - An implementation of the Mars Rover kata in Elixir transformed in a basic multiplayer game.
    • vim_snake - A classical multiplayer snake game with Vim-style keybinding built with Phoenix framework.

  • HTTP

    • bolt - Simple and fast http proxy.
    • Crawly - high-level web crawling & scraping framework for Elixir.
    • finch - An HTTP client with a focus on performance, built on top of Mint and NimblePool.
    • httpotion - Fancy HTTP client for Elixir, based on ibrowse.
    • mint - Functional HTTP client for Elixir with support for HTTP/1 and HTTP/2.
    • plug_wait1 - Plug adapter for the wait1 protocol.
    • sparql_client - A [SPARQL protocol](https://www.w3.org/TR/sparql11-protocol/) client for Elixir.
    • tesla - HTTP client library, with support for middleware and multiple adapters.
    • Ace - HTTP web server and client, supports http1 and http2.
    • cauldron - An HTTP/SPDY server as a library.
    • Crawler - A high performance web crawler in Elixir.
    • elli - Elli is a webserver you can run inside your Erlang application to expose an HTTP API.
    • etag_plug - A simple to use shallow ETag plug.
    • explode - An easy utility for responding with standard HTTP/JSON error payloads in Plug- and Phoenix-based applications.
    • exvcr - HTTP request/response recording library for Elixir, inspired by VCR.
    • finch - An HTTP client with a focus on performance, built on top of Mint and NimblePool.
    • fuzzyurl - An Elixir library for parsing, constructing, and wildcard-matching URLs. Also available for [Ruby](https://github.com/gamache/fuzzyurl.rb) and [JavaScript](https://github.com/gamache/fuzzyurl.js).
    • gun - HTTP/1.1, HTTP/2 and Websocket client for Erlang/OTP.
    • hackney - Simple HTTP client written in Erlang.
    • http - HTTP server for Elixir.
    • http_digex - A module to create basic digest HTTP auth header.
    • http_proxy - Multi port HTTP Proxy.
    • httpoison - Yet Another HTTP client for Elixir powered by hackney.
    • ivar - A lightweight wrapper around HTTPoison that provides a fluent and composable way to build http requests.
    • lhttpc - A lightweight HTTP/1.1 client implemented in Erlang.
    • Mechanize - Build web scrapers and automate interaction with websites in Elixir with ease.
    • mnemonic_slugs - A memorable, mnemonic slug generator in Elixir.
    • mochiweb - MochiWeb is an Erlang library for building lightweight HTTP servers.
    • neuron - A GraphQL client for Elixir.
    • plug_wait1 - Plug adapter for the wait1 protocol.
    • raxx - Interface for HTTP webservers, frameworks and clients.
    • river - An HTTP/2 client that is lightweight and lightning fast.
    • scrape - Scrape any website, article or RSS/Atom Feed with ease.
    • sparql_client - A [SPARQL protocol](https://www.w3.org/TR/sparql11-protocol/) client for Elixir.
    • spell - Spell is a [Web Application Messaging Protocol](http://wamp-proto.org/) (WAMP) client implementation in Elixir.
    • SpiderMan - A base-on Broadway fast high-level web crawling & scraping framework for Elixir.
    • Tube - Pure Elixir WebSocket client library.
    • uri_query - URI encode nested GET parameters and array values in Elixir.
    • uri_template - RFC6570 compliant URI template processor for Elixir.
    • web_socket - An exploration into a stand-alone library for Plug applications to easily adopt WebSockets.
    • webdriver - This is an implementation of the WebDriver protocol client. It currently supports PhantomJS, FireFox, ChromeDriver and remote webdriver servers (e.g. Selenium).
    • yuri - Simple struct for representing URIs.

  • Images

    • image64 - A tool for working with base64 encoded images.
    • elixir_exif - Parse exif tags and thumbnail data from jpeg files.
    • ex_image_info - An Elixir library to parse images (binaries) and get the dimensions, detected mime-type and overall validity for a set of image formats.
    • imagineer - Image parsing in Elixir.
    • mogrify - An Elixir wrapper for ImageMagick command line.
    • alchemic_avatar - Elixir library for generating letter avatar from string.
    • artifact - File upload and on-the-fly processing for Elixir.
    • bump - A BMP file writer in pure Elixir.
    • chunky_svg - A library for drawing things with SVG.
    • cloudex - Cloudex is an Elixir library that can upload image files or urls to Cloudinary.
    • eikon - An Elixir library providing a read-only interface for image files.
    • elixir_exif - Parse exif tags and thumbnail data from jpeg files.
    • ex_image_info - An Elixir library to parse images (binaries) and get the dimensions, detected mime-type and overall validity for a set of image formats.
    • exexif - Pure Elixir library to extract TIFF and EFIX metadata from jpeg files.
    • exfavicon - An Elixir library for discovering favicons.
    • gi - An Elixir wrapper for GraphicsMagick command line.
    • identicon - An Elixir library for generating 5x5 identicons.
    • imgex - Unofficial client library for generating imgix URLs in Elixir.
    • png - A pure Erlang library for creating PNG images. It can currently create 8 and 16 bit RGB, RGB with alpha, indexed, grayscale and grayscale with alpha images.
    • thumbnex - Create thumbnails from images and video screenshots.
    • thumbor_client - Client for Thumbor.

  • Logging

    • exsentry - Error logging to [Sentry](https://getsentry.com/).
    • quiet_logger - A simple plug to suppress health check logging (e.g.: when using Kubernetes).
    • rollbax - Exception tracking and logging to [Rollbar](https://rollbar.com/).
    • timber - Structured logging platform; turns raw text logs into rich structured events.
    • bunyan - Bunyan: An Elixir Logger.
    • ecto_dev_logger - An alternative logger for Ecto queries that helps in debugging.
    • exlager - Elixir binding for lager.
    • gelf_logger - A Logger backend that will generate Graylog Extended Log Format (GELF) messages.
    • honeybadger - Error logging to [Honeybadger](https://www.honeybadger.io/).
    • json_logger - JSON Logger is a logger backend that outputs elixir logs in JSON format.
    • lager - A logging framework for Erlang/OTP by basho.com.
    • lager_logger - A lager backend that forwards all log messages to Elixir's Logger.
    • logfmt - Logfmt is a module for encoding and decoding logfmt-style log lines.
    • logger_logstash_backend - A backend for the Elixir Logger that will send logs to the Logstash UDP input.
    • logglix - A logger backend for posting errors to Loggly.
    • logster - Easily parsable, one-line logging for Phoenix and Plug applications, inspired by Lograge.
    • metrix - Log custom app metrics to stdout for use by Librato and other downstream processors.
    • mstore - MStore is a experimental metric store build in erlang, the primary functions are open, new, get and put.
    • rogger - Elixir logger to publish log messages in RabbitMQ.
    • rollbax - Exception tracking and logging to [Rollbar](https://rollbar.com/).
    • slack_logger_backend - A logger backend for posting errors to Slack.
    • syslog - Erlang port driver for interacting with syslog via syslog(3).
    • timber - Structured logging platform; turns raw text logs into rich structured events.
    • youtrack_logger_backend - A logger backend that will post messages to [YouTrack](https://www.jetbrains.com/youtrack/) (an issue tracker made by JetBrains).

  • ORM and Datamapping

    • ecto_factory - Easily generate structs based on your ecto schemas.
    • hstore - Hstore support for Postgrex.
    • unreal - Unofficial SurrealDB driver for Elixir.
    • couchdb_connector - A connector for CouchDB, the Erlang-based, JSON document database.
    • ets_map - An Elixir package that provides a Map-like interface (Map/Access/Enumerable/Collectable) backed by an ETS table.
    • eventstore - A CQRS EventStore using Postgres for persistence, written in Elixir.
    • exredis - Redis client for Elixir.
    • mongodb - MongoDB driver for Elixir.
    • mongodb_ecto - MongoDB adapter for Ecto.
    • pillar - Clickhouse HTTP based client.
    • sqlitex - An Elixir wrapper around esqlite. Allows access to sqlite3 databases.
    • ssdb_elixir - ssdb client for Elixir, with focus on performance.
    • tds - MSSQL / TDS Database driver for Elixir.
    • xandra - Cassandra driver built natively in Elixir and focused on speed, simplicity, and robustness.
    • amnesia - Mnesia wrapper for Elixir.
    • arbor - Ecto adjacency list and tree traversal.
    • arc_ecto - Arc.Ecto provides an integration with Arc and Ecto.
    • atlas - Object Relational Mapper for Elixir.
    • barrel_ex - [Barrel-db](https://barrel-db.org/) distributed document-oriented database REST client in Elixir.
    • Bolt.Sips - Neo4j driver for Elixir using the Bolt protocol.
    • boltun - Transforms notifications from the Postgres LISTEN/NOTIFY mechanism into callback execution.
    • caylir - Cayley driver for Elixir.
    • comeonin_ecto_password - Ecto custom type for storing encrypted password using Comeonin.
    • couchdb_connector - A connector for CouchDB, the Erlang-based, JSON document database.
    • craterl - Erlang client for crate.
    • database_url - Parse database URL and return keyword list for use with Ecto.
    • datomex - Elixir driver for the Datomic REST API.
    • ddb_client - DalmatinerDB client.
    • defql - Create elixir functions with SQL as a body.
    • dexts - Disk Elixir Terms Storage, dest wrapper.
    • diver - A HBase driver for Erlang/Elixir using Jinterface and the Asynchbase Java client to query the database.
    • dproto - Protocols for DalmatinerDB.
    • dqe - DalmatinerDB query engine.
    • ecto - A database wrapper and language integrated query for Elixir.
    • ecto_anon - Simple way to handle data anonymization directly in your Ecto schemas.
    • ecto_cassandra - Cassandra DB Adapter for Ecto.
    • ecto_enum - Ecto extension to support enums in models.
    • ecto_facade - Ecto facade that allows to separate writes and reads to different databases.
    • ecto_fixtures - Fixtures for Elixir apps using Ecto.
    • ecto_lazy_float - Ecto.LazyFloat - An Ecto.Float that accepts binary and integers.
    • ecto_list - Simple ordered model management with Ecto.
    • ecto_migrate - Ecto auto migration library. It allows to generate and run migrations for initial and update migrations.
    • ecto_mnesia - Ecto adapter for Mnesia Erlang term database.
    • ecto_ordered - Ecto extension for ordered models.
    • ecto_paging - Cursor-based pagination for Ecto.
    • ecto_psql_extras - Ecto PostgreSQL database performance insights.
    • ecto_rut - Simple and Powerful Ecto Shortcuts to simplify and speed up development.
    • ecto_shortcuts - Shortcuts for common operations in ecto.
    • ecto_shortuuid - Ecto type which adds support for [ShortUUIDs](https://github.com/gpedic/ex_shortuuid).
    • ecto_validation_case - Simplify your Ecto model validation tests. Loosely inspired by shoulda matchers, but simpler.
    • ectophile - Ecto extension to instantly support file uploads in models.
    • elastic - A thin-veneer over HTTPotion to help you talk to Elastic Search.
    • elastix - A simple Elastic REST client written in Elixir.
    • eredis - Erlang Redis client.
    • erlastic_search - An Erlang app for communicating with Elastic Search's rest interface.
    • esqlite - Erlang NIF for sqlite.
    • eternal - Keep your ETS tables alive forever, safely and easily.
    • ets_map - An Elixir package that provides a Map-like interface (Map/Access/Enumerable/Collectable) backed by an ETS table.
    • ex_bitcask - Elixir wrapper of Basho's Bitcask Key/Value store.
    • ex_sider - Elixir Map/List/Set interfaces for Redis data structures (uses Redix, but that is configurable).
    • exleveldb - Elixir wrapper around Basho's eleveldb module for LevelDB.
    • exnumerator - Elixir enumerable type definition in a simple way to be used with any database.
    • exseed - An Elixir library that provides a simple DSL for seeding databases through Ecto.
    • exsolr - A Solr wrapper written in Elixir.
    • extreme - An Elixir library using [Eventstore](https://geteventstore.com) for persistence of events generated by aggregates (CQRS).
    • exts - Elixir Terms Storage, ets wrapper.
    • github_ecto - Ecto adapter for GitHub API.
    • gremlex - Apache Tinkerpop Gremlin Elixir Client.
    • inquisitor - Composable query builder for Ecto.
    • isn - Ecto types for the postgreSQL isn extension.
    • kalecto - Glue between Kalends and Ecto for saving dates, times and datetimes.
    • kvs - Erlang Abstract Term Database.
    • level - Level for Elixir implements various helper functions and data types for working with Googles Level data store.
    • mariaex - MariaDB/MySQL driver for Elixir.
    • memento - Simple Mnesia Interface in Elixir.
    • moebius - A functional query tool for Elixir and PostgreSQL.
    • mongo - MongoDB driver for Elixir.
    • mongodb_driver - Alternative driver for MongoDB with support for recent versions of MongoDB and comprehensive feature list.
    • mysql - MySQL/OTP – MySQL driver for Erlang/OTP.
    • mysqlex - An Ecto-compatible wrapper around the mysql-otp library.
    • neo4j_sips - Neo4j driver for Elixir.
    • neo4j_sips_models - Minimalistic Model support for the Neo4j.Sips Elixir driver.
    • panoramix - Apache Druid client for Elixir.
    • paper_trail - Ecto plugin for tracking and recording all the changes in your database.
    • postgrex - PostgreSQL driver for Elixir.
    • ravix - RavenDB Driver for Elixir.
    • ravix-ecto - RavenDB Ravix Driver adapter for Ecto.
    • red - Persist relationships between objects in Redis, in a graph-like way.
    • rediscl - A minimal redis client with connection pooling and pipe query builder.
    • redix - Superfast, pipelined, resilient Redis driver for Elixir.
    • redo - Heroku's pipelining redis client for erlang.
    • rethinkdb - Rethinkdb client in pure Elixir using JSON protocol.
    • riak - A Riak client written in Elixir.
    • riak_ecto - Riak adapter for Ecto.
    • shards - Transparent and out-of-box Sharding support for Erlang/Elixir ETS tables.
    • sql_dust - Generate (complex) SQL queries using magical Elixir SQL dust.
    • sqlite_ecto - SQLite3 adapter for Ecto.
    • sqlitex - An Elixir wrapper around esqlite. Allows access to sqlite3 databases.
    • ssdb_elixir - ssdb client for Elixir, with focus on performance.
    • tds - MSSQL / TDS Database driver for Elixir.
    • tds_ecto - MSSQL / TDS Adapter for Ecto.
    • timex_ecto - An adapter for using Timex DateTimes with Ecto.
    • tirexs - An Elixir flavored DSL for building JSON based requests to Elasticsearch engine.
    • triplex - Database multitenancy with postgres schemas for Elixir applications.
    • triton - Pure Elixir Cassandra ORM built on top of Xandra.
    • udpflux - An opinionated InfluxDB UDP only client.
    • walex - PostgreSQL Change Data Capture (CDC) events listener in Elixir.
    • yar - Yet another Redis client for Elixir.
    • ecto_watch - Allows you to easily get notifications about database changes directly from PostgreSQL.

  • Package Management

    • Hex - A package manager for the Erlang ecosystem.
    • rebar3_hex - Hex.pm plugin for rebar3.
    • rebar3_hex - Hex.pm plugin for rebar3.

  • Protocols

    • grpc-elixir - The Elixir implementation of gRPC.
    • grpc-elixir - The Elixir implementation of gRPC.
    • borsh - Elixir implementation of the [BORSH](https://borsh.io) binary serializer.
    • elixir_radius - RADIUS Protocol on Elixir.
    • ex_hl7 - Health Level 7 (HL7) is a protocol designed to model and transfer health-related data electronically.
    • ex_marshal - Ruby Marshal format implemented in Elixir.
    • exprotobuf - Protocol Buffers in Elixir, made easy.
    • message_pack - MessagePack Implementation for Elixir.
    • msgpax - MessagePack (de)serializer implementation for Elixir.
    • protox - Elixir implementation for Protocol Buffers.
    • riffed - Provides idiomatic Elixir bindings for Apache Thrift.
    • Sippet - An Elixir library designed to be used as SIP protocol middleware.
    • SMPPEX - SMPP 3.4 protocol and framework implementation in Elixir.

  • Queue

    • stream_weaver - Library for working with streams.
    • adap - Create a data stream across your information systems to query, augment and transform data according to Elixir matching rules.
    • mqs - RabbitMQ client library, routing keys, RPC over MQ and other stuff.
    • Rihanna - High performance postgres-backed job queue for Elixir.
    • adap - Create a data stream across your information systems to query, augment and transform data according to Elixir matching rules.
    • amqp - Simple Elixir wrapper for the Erlang RabbitMQ client, based on Langohr.
    • broadway - Concurrent and multi-stage data ingestion and data processing with Elixir.
    • conduit - A framework for working with message queues, with adapters for SQS and AMQP, and plugs for reusable messaging patterns.
    • cspex - Simple, OTP compliant, Elixir implementation of CSP channels.
    • dbus - A dumb message bus for sharing data between microservices decoupled using Redis.
    • ecto_job - A transactional job queue built with Ecto, PostgreSQL and GenStage.
    • elixir_nsq - NSQ client library for Elixir.
    • elixir_talk - An Elixir client for beanstalkd.
    • enm - enm is an Erlang port driver that wraps the nanomsg C library.
    • exdisque - Elixir client for [Disque](https://github.com/antirez/disque), an in-memory, distributed job queue.
    • exq - Job processing library for Elixir - compatible with Resque/Sidekiq.
    • exrabbit - RabbitMQ bindings and DSL for Elixir.
    • faktory_worker - An Elixir library for working with [Faktory](https://contribsys.com/faktory/), a polyglot job processing system made by the author of Sidekiq.
    • flume - A blazing fast job processing system backed by GenStage & Redis.
    • gen_rmq - Set of behaviours meant to be used to create RabbitMQ consumers and publishers.
    • heapq - A Heap-based Priority Queue Implementation in Elixir.
    • honeycomb - Another scheduling system, focusing on the collection of results for one-time tasks.
    • honeydew - Honeydew is a worker pool library for Elixir.
    • hulaaki - An MQTT 3.1.1 client library written in Elixir.
    • kaffe - Kafka client library for Elixir.
    • mqs - RabbitMQ client library, routing keys, RPC over MQ and other stuff.
    • opq - A simple, in-memory queue with worker pooling and rate limiting in Elixir.
    • pqueue - Erlang Priority Queue Implementation.
    • que - Simple Background Job Processing with Mnesia.
    • queuex - Priority Queue with multiple backends.
    • RBMQ - Simple API for spawning RabbitMQ Producers and Consumers.
    • task_bunny - background processing application written in Elixir and uses RabbitMQ as a messaging backend.
    • toniq - Simple and reliable background job library for Elixir.
    • verk - Verk is a job processing system backed by Redis. It uses the same job definition of Sidekiq/Resque.
    • work_queue - Simple implementation of the hungry-consumer model in Elixir.

  • Security

    • Ockam - A suite of tools, programming libraries and infrastructure that make it easy to build devices that communicate securely, privately and trustfully with cloud services and other devices. [Docs](https://www.ockam.io/learn/concepts/) .
    • Ockam - A suite of tools, programming libraries and infrastructure that make it easy to build devices that communicate securely, privately and trustfully with cloud services and other devices. [Docs](https://www.ockam.io/learn/concepts/) .
    • ca - Certificate Authority.
    • clamxir - ClamAV wrapper for elixir.
    • code_signing - Signing and verifying BEAM files with Ed25519 signatures.
    • pwned - Check if your password has been pwned.
    • safetybox - Security oriented helper functions for Elixir.
    • site_encrypt - Integrated certification via Let's encrypt for Elixir-powered sites.
    • sobelow - Security-focused static analysis for the Phoenix Framework.
    • ssl_verify_fun - Collection of ssl verification functions for Erlang.
    • Ockam - A suite of tools, programming libraries and infrastructure that make it easy to build devices that communicate securely, privately and trustfully with cloud services and other devices. [Docs](https://www.ockam.io/learn/concepts/) .

  • SMS

    • exsms - An Elixir library for sending transactional SMS - supports Sendinblue, mailjet, msg91 and textlocal.

  • Third Party APIs

    • exlingr - A Lingr client module.
    • hexoku - Heroku API client and Heroku Mix tasks for Elixir projects.
    • m2x - Elixir client for the AT&T M2X, a cloud-based fully managed time-series data storage service for network connected machine-to-machine (M2M) devices and the Internet of Things (IoT). ([Erlang Version](https://github.com/attm2x/m2x-erlang)).
    • random_user_api - Another simple randomuser.me API client.
    • stripe - An Elixir Library wrapping Stripe's API.
    • amazon_product_advertising_client - Amazon Product Advertising API client for Elixir.
    • balalaika_bear - Simple VK API client for Elixir.
    • bandwidth - An Elixir client library for the Bandwidth Application Platform.
    • conekta - Elixir wrapper for Conekta API.
    • digoc - Digital Ocean API v2 Elixir Client.
    • ethereumex - Elixir JSON-RPC client for the Ethereum blockchain.
    • exdesk - Elixir library for the Desk.com API.
    • exstagram - Elixir library for Instagram v1 API.
    • google-cloud - This repository contains all the client libraries to interact with Google APIs.
    • pagexduty - A Pagerduty client for Elixir.
    • random_user - An Elixir client for randomuser.me API.
    • stripity_stripe - An Elixir Library for [Stripe](https://stripe.com/).
    • tradehub - An Elixir client library for the Tradehub blockchain.
    • ui_faces - UIFaces API client for Elixir applications.
    • random_user - An Elixir client for randomuser.me API.
    • airbax - Exception tracking from Elixir to Airbrake.
    • airbrake - An Elixir notifier for the Airbrake.
    • airbrakex - Elixir client for the Airbrake service.
    • apns - Apple Push Notifications Service client library for elixir.
    • asanaficator - Simple Elixir wrapper for the Asana API. Based on Tentacat.
    • askimet_ex - Elixir client for Askimet Anti-Spam service.
    • assembla_api - Assembla API client for Elixir.
    • balalaika_bear - Simple VK API client for Elixir.
    • balanced - Balanced API Client for Elixir.
    • bandwidth - An Elixir client library for the Bandwidth Application Platform.
    • bing_translator - A simple Elixir interface to Bing's translation API.
    • bitmex - BitMEX client library for Elixir.
    • bitpay - Elixir core library for connecting to bitpay.com.
    • cashier - Payment gateway offering a common interface into multiple payment providers.
    • chargebeex - An Elixir client for Chargebee API.
    • cleverbot - Simple implementation of the Cleverbot API in Elixir.
    • coinbase - A unofficial Coinbase API v1 Client.
    • commerce_billing - A payment-processing library for Elixir that supports multiple gateways (e.g. Bogus & Stripe).
    • conekta - Elixir wrapper for Conekta API.
    • correios_cep - Find Brazilian addresses by zip code, directly from Correios database. No HTML parsers.
    • currently - A tool to display cards currently assigns on Trello.
    • darkskyx - A Darksky.com (formerly forecast.io) API client for Elixir.
    • digitalocean - Elixir wrapper for the Digital Ocean API v2.
    • digoc - Digital Ocean API v2 Elixir Client.
    • diplomat - A [Google Cloud Datastore](https://cloud.google.com/datastore/) client.
    • dnsimple - Elixir client for the DNSimple API v2.
    • docker - Elixir client for the Docker Remote API.
    • dockerex - Lightweight Docker Remote API Client with SSL/TLS login/connection support.
    • dogstatsd - An Elixir client for [DogStatsd](https://www.datadoghq.com/).
    • dpd_client - An API client for the DPD service.
    • dropbox - Dropbox Core API client for Elixir.
    • dublin_bus_api - Access to the Real Time Passenger Information (RTPI) for Dublin Bus services.
    • edgarex - Elixir interface for fetching SEC filings from EDGAR.
    • elixir_authorizenet - Unofficial client for the Authorize.Net merchant API.
    • elixir_ipfs_api - IPFS (InterPlanetary File System) API client for Elixir.
    • elixirfm - Last.fm API wrapper for Elixir.
    • elixtagram - Instagram API client for Elixir.
    • ethereumex - Elixir JSON-RPC client for the Ethereum blockchain.
    • everex - Evernote API client for Elixir.
    • everyoneapi - API Client for EveryoneAPI.com.
    • ex_changerate - Elixir client for [exchangerate.host](https://exchangerate.host) API.
    • ex_codeship - API Client for Codeship.
    • ex_statsd - A statsd client implementation for Elixir.
    • ex_twilio - Twilio API client for Elixir.
    • ex_twiml - Generate TwiML for your Twilio integration, right inside Elixir.
    • exdesk - Elixir library for the Desk.com API.
    • exfacebook - Facebook API, written in Elixir using similar methods like Ruby koala gem.
    • exgenius - Elixir library for the (undocumented) Rap Genius API.
    • exgravatar - An Elixir module for generating Gravatar URLs.
    • exgrid - interact with Sendgrid's API.
    • exjira - JIRA client library for Elixir.
    • explay - Unofficial Google Play API in Elixir.
    • exstagram - Elixir library for Instagram v1 API.
    • extwitter - Twitter client library for Elixir.
    • exurban - Elixir wrapper for UrbanAirship API.
    • facebook - Facebook Graph API Wrapper written in Elixir.
    • feedlex - Feedly RSS reader client for Elixir.
    • fluent_client - Minimalistic fluentd client.
    • forcex - Elixir library for the Force.com REST API.
    • forecast_io - Simple wrapper for Forecast.IO API.
    • gcmex - Google Cloud Messaging client library for elixir.
    • google-cloud - This repository contains all the client libraries to interact with Google APIs.
    • google_sheets - Elixir library for fetching and polling Google spreadsheet data in CSV format.
    • govtrack - A simple Elixir wrapper for the [govtrack.us](https://www.govtrack.us/developers) API.
    • gringotts - A complete payment library for Elixir and Phoenix Framework similar to [ActiveMerchant](https://github.com/activemerchant/active_merchant) from the Ruby world.
    • honeywell - A client for the Honeywell Lyric, Round and Water Leak & Freeze Detector APIs.
    • kane - A [Google Cloud Pub/Sub](https://cloud.google.com/pubsub/overview) client.
    • keenex - A Keen.io API Client.
    • link_shrinkex - Elixir library for creating short URLs using Google's URL Shortener API.
    • mailchimp - A basic Elixir wrapper for version 3 of the MailChimp API.
    • mailgun - Elixir Mailgun Client.
    • mandrill - A Mandrill wrapper for Elixir.
    • marvel - CLI and Elixir API Client for the Marvel API.
    • mexpanel - An Elixir client for the Mixpanel HTTP API.
    • mixpanel - An Elixir client for the Mixpanel HTTP API.
    • mixpanel_data_client - Client for interacting with the Mixpanel Data Export API.
    • mmExchangeRate - A simple exchange rate checker and calculator based on Central Bank of Myanmar Api.
    • nacha - Elixir library for generating and parsing NACHA files for US ACH transfers.
    • nadia - Telegram Bot API Wrapper written in Elixir.
    • omise - Omise client library for Elixir.
    • opbeat - Elixir client for Opbeat.
    • pagexduty - A Pagerduty client for Elixir.
    • parse_client - Elixir client for the parse.com REST API.
    • parsex - ParsEx is an Elixir HTTP Client for communicating with Parse.com's Restful API.
    • particle - An Elixir client for the Particle IoT platform's HTTP API.
    • pathway - An Erlang/Elixir client for the [Trak.io](http://trak.io/) REST API.
    • pay - An Elixir Lib to deal with Paypal and other payment solutions.
    • pay_pal - Elixir library for working with the PayPal REST API.
    • pigeon - HTTP2-compliant wrapper for sending iOS and Android push notifications.
    • pocketex - Pocketex is an Elixir client for the Pocket read later service [getpocket.com](https://getpocket.com/).
    • pusher - Elixir library to access the Pusher REST API.
    • qiita_ex - A Qiita API v2 Interface for Elixir.
    • qiniu - Qiniu SDK for Elixir.
    • reap - Reap is a simple Elixir library for working with the refheap API.
    • reddhl - An headline and link puller for Reddit and its various subreddits.
    • redtube - Redtube API Wrapper written in Elixir.
    • reporter - Reporter is simple reporting App reviews library. Support AppStore and GooglePlay.
    • riemann - A [Riemann](http://riemann.io/) client for Elixir.
    • rs_twitter - Low Level Twitter Client for Elixir.
    • semver - Utilities for working with semver.org-compliant version strings.
    • sendgrid - Send composable, transactional emails with SendGrid.
    • shopify - Easily access the Shopify API.
    • sift_ex - A Siftscience API Library for Elixir.
    • simplex - An Elixir library for interacting with the Amazon SimpleDB API.
    • slack - Slack real time messaging client in Elixir.
    • sparkpost - An Elixir library for sending email using SparkPost.
    • statix - Expose app metrics in the StatsD protocol.
    • stripity_stripe - An Elixir Library for [Stripe](https://stripe.com/).
    • tagplay - Elixir client for Tagplay API.
    • telegex - Telegram bot framework and API client written in Elixir.
    • telephonist - Elixir state machines for Twilio calls.
    • tentacat - Simple Elixir wrapper for the GitHub API.
    • tg_client - An Elixir wrapper which communicates with the Telegram-CLI.
    • tradehub - An Elixir client library for the Tradehub blockchain.
    • traitify_elixir - An Elixir client library for the Traitify Developer's API.
    • ui_faces - UIFaces API client for Elixir applications.
    • unsplash-elixir - An Elixir library for Unsplash.
    • vultr - Simple wrapper for the Vultr API.
    • xe - Real time conversion for currencies.
    • zanox - Zanox API.

  • Translations and Internationalizations

    • free PO editor - A tool for translating PO files.
    • gettext - Internationalization and localization support for Elixir.
    • trans - A Elixir library to manage embedded translations into models leveraging PostgreSQL JSONB datatype.
    • exkanji - A Elixir library for translating between hiragana, katakana, romaji and kanji. It uses Mecab.
    • exromaji - A Elixir library for translating between hiragana, katakana and romaji.
    • getatrex - Automatic translation tool of Gettext locales with Google Translate for Elixir/Phoenix projects.
    • linguist - Elixir Internationalization library.
    • parabaikElixirConverter - ParabaikElixirConverter is just a Elixir version of Parabaik converter. It can convert from Unicode to Zawgyi-One and Zawgyi-One to Unicode vice versa.
    • trans - A Elixir library to manage embedded translations into models leveraging PostgreSQL JSONB datatype.

  • Books

    • Adopting Elixir - Bring Elixir into your company, with real-life strategies from the people who built Elixir and use it successfully at scale. This book has all the information you need to take your application from concept to production (2017).
    • Craft GraphQL APIs in Elixir with Absinthe - Upgrade your web API to GraphQL, leveraging its flexible queries to empower your users, and its declarative structure to simplify your code (2017).
    • Elixir in Action, Second Edition - Revised and updated for Elixir 1.7, Elixir in Action, Second Edition teaches you how to apply Elixir to practical problems associated with scalability, fault tolerance, and high availability (2019).
    • Elixir in Action, Third Edition - Fully updated to Elixir 1.14, this authoritative bestseller reveals how Elixir tackles problems of scalability, fault tolerance, and high availability (2023).
    • Elixir Succinctly - A short book to learn the basic of Elixir and its ecosystem.
    • Erlang and Elixir for Imperative Programmers - Introduction to Erlang and Elixir in the context of functional concepts by Wolfgang Loder (2016).
    • Erlang in Anger - This book intends to be a little guide about how to be the Erlang medic in a time of war by Fred Hebert (2014).
    • Functional Web Development with Elixir, OTP, and Phoenix - Open doors to powerful new techniques that will get you thinking about web development in fundamentally new ways (2017).
    • Hands-on Elixir & OTP: Cryptocurrency trading bot - Want to learn Elixir & OTP by creating a real-world project? With Hands-on *Elixir & OTP: Cryptocurrency trading bot* you will gain hands-on experience by working on an interesting software project. We will explore all the key abstractions and essential principles through iterative implementation improvements. (2021).
    • Learn Functional Programming with Elixir - Don’t board the Elixir train with an imperative mindset! To get the most out of functional languages, you need to think functionally (2017).
    • Metaprogramming Elixir: Write Less Code, Get More Done (and Have Fun!) - Thorough explanation on how to exploit Elixir's metaprogramming capabilities to improve your Elixir coding by Chris McCord (2015).
    • Phoenix for Rails Developers - This book shows how Rails developers can benefit from their existing knowledge to learn Phoenix. By Elvio Vicosa (2017).
    • Phoenix in Action - builds on your existing web dev skills, teaching you the unique benefits of Phoenix along with just enough Elixir to get the job done. By Geoffrey Lessel (2017).
    • Phoenix Inside Out - The goal of this series is to enable you as a Confident Phoenix developer. There are 3 different editions to address varied needs of devs jumping into Phoenix.
    • Programming Elixir 1.6 - The book provides introduction to functional and concurrent programming with Elixir by Dave Thomas (2014).
    • The Beam Book - A description of the Erlang Runtime System ERTS and the virtual Machine BEAM.
    • The Little Elixir & OTP Guidebook - A book for learning Elixir and OTP through small to medium-sized projects by Benjamin Tan Wei Hao (2014).
    • Engineering Elixir Applications - _(currently in Beta)_ As the subtitle suggests, this book explores the technologies and skills that support navigating each stage of software delivery with confidence.
    • Adopting Elixir - Bring Elixir into your company, with real-life strategies from the people who built Elixir and use it successfully at scale. This book has all the information you need to take your application from concept to production (2017).
    • Craft GraphQL APIs in Elixir with Absinthe - Upgrade your web API to GraphQL, leveraging its flexible queries to empower your users, and its declarative structure to simplify your code (2017).
    • Elixir Cookbook - This book is a set of recipes grouped by topic by Paulo A Pereira (2015).
    • Elixir Succinctly - A short book to learn the basic of Elixir and its ecosystem.
    • Functional Web Development with Elixir, OTP, and Phoenix - Open doors to powerful new techniques that will get you thinking about web development in fundamentally new ways (2017).
    • Hands-on Elixir & OTP: Cryptocurrency trading bot - Want to learn Elixir & OTP by creating a real-world project? With Hands-on *Elixir & OTP: Cryptocurrency trading bot* you will gain hands-on experience by working on an interesting software project. We will explore all the key abstractions and essential principles through iterative implementation improvements. (2021).
    • Introducing Elixir - A gentle introduction to the language, with lots of code examples and exercises by Simon St. Laurent and J. David Eisenberg (2013).
    • Learn Functional Programming with Elixir - Don’t board the Elixir train with an imperative mindset! To get the most out of functional languages, you need to think functionally (2017).
    • Metaprogramming Elixir: Write Less Code, Get More Done (and Have Fun!) - Thorough explanation on how to exploit Elixir's metaprogramming capabilities to improve your Elixir coding by Chris McCord (2015).
    • Phoenix for Rails Developers - This book shows how Rails developers can benefit from their existing knowledge to learn Phoenix. By Elvio Vicosa (2017).
    • Phoenix in Action - builds on your existing web dev skills, teaching you the unique benefits of Phoenix along with just enough Elixir to get the job done. By Geoffrey Lessel (2017).
    • The Beam Book - A description of the Erlang Runtime System ERTS and the virtual Machine BEAM.
    • The Phoenix LiveView Cookbook - A Phoenix LiveView e-book containing tried and tested recipes for solving common problems.
    • Elixir Cookbook - This book is a set of recipes grouped by topic by Paulo A Pereira (2015).
    • Elixir do zero à concorrência - (Portuguese) The book provides introduction to functional and concurrent programming with Elixir by Tiago Davi (2014).
    • Elixir in Action - A brief intro to the language followed by a more detailed look at building production-ready systems in Elixir by Saša Jurić (2015).
    • Programming Phoenix 1.4 - Definitive guide to build web applications with the Phoenix framework by Chris McCord, José Valim and Bruce Tate (2015).
    • Études for Elixir - A collection of exercises to program in Elixir by J. David Eisenberg (2013) ([Github Repo](https://github.com/oreillymedia/etudes-for-elixir)).
    • Async Elixir - Dive into Elixir's world of concurrency and processes with this interactive Livebook.
    • Getting Started - Elixir - PDF, MOBI, and EPUB documents for Elixir's Getting Started tutorial (2016).
    • Introducing Elixir - A gentle introduction to the language, with lots of code examples and exercises by Simon St. Laurent and J. David Eisenberg (2013).

  • Community

    • #elixir-lang - The IRC Channel #elixir-lang on Freenode.
    • Elixir Forum - Community run discussion forums for all things Elixir.
    • elixir-lang-core - Mailinglist for Elixir Core development, use "talk" for questions and general discussions.
    • elixir-lang-talk - Official Elixir Mailinglist for questions and discussions.
    • ElixirSlack - Elixir Slack Community.
    • #elixir-lang - The IRC Channel #elixir-lang on Freenode.
    • elixir-lang-core - Mailinglist for Elixir Core development, use "talk" for questions and general discussions.
    • elixir-lang-talk - Official Elixir Mailinglist for questions and discussions.
    • #elixir-lang - The IRC Channel #elixir-lang on Freenode.

  • Editors

    • Atom - Elixir language support for Atom.
    • elixir-tmbundle - A TextMate and SublimeText bundle for Elixir.
    • vim-elixir - Vim configuration files for Elixir.
    • Atom - Elixir language support for Atom.
    • elixir-tmbundle - A TextMate and SublimeText bundle for Elixir.
    • vim-elixir - Vim configuration files for Elixir.

  • Newsletters

    • Elixir Radar - The "official" Elixir newsletter, published weekly via email by Plataformatec.
    • ElixirWeekly - The Elixir community newsletter, covering stuff you easily miss, shared on [ElixirStatus](http://elixirstatus.com) and the web.
    • Elixir Radar - The "official" Elixir newsletter, published weekly via email by Plataformatec.
    • ElixirWeekly - The Elixir community newsletter, covering stuff you easily miss, shared on [ElixirStatus](http://elixirstatus.com) and the web.
    • Elixir Merge - A daily newsletter which delivers two curated updates (articles, tutorials, videos, podcasts) in each edition in quick-read format.
    • Elixir Digest - A weekly newsletter with the latest articles on Elixir and Phoenix.

  • Other Awesome Lists

  • Podcasts

  • Reading

  • Screencasts

    • Alchemist Camp - Alchemist.Camp has many hours of free, project-based Elixir-learning screencasts.
    • Confreaks (Elixir) - Elixir related conference talks.
    • Curso de Elixir de 0 a 100 - Complete course of elixir (in spanish) for free.
    • Elixir for Programmers - Functional, Parallel, Reliable (and fun!), taught by Dave Thomas.
    • Elixir Foundation - Learn Elixir by building a practical example. Learn how GenServer, Agents and many other elixir primitives work.
    • Elixir Sips - Tiny screencasts for learning Elixir.
    • ElixirCasts.io - Simple screencasts to help you learn Elixir and Phoenix.
    • ExCasts - Elixir and Phoenix screencasts for all skill levels.
    • Kamil Skowron - YouTube channel dedicated to promote functional programming, publishing "real world" programming videos in Elixir like "Hands-on Elixir & OTP: Cryptocurrency trading bot" series.
    • LearnElixir.tv - Beginner friendly, in-depth, step by step screencasts.
    • LearnPhoenix.tv - Learn how to build fast, dependable web apps with Phoenix.
    • Alchemist Camp - Alchemist.Camp has many hours of free, project-based Elixir-learning screencasts.
    • Elixir Foundation - Learn Elixir by building a practical example. Learn how GenServer, Agents and many other elixir primitives work.
    • Kamil Skowron - YouTube channel dedicated to promote functional programming, publishing "real world" programming videos in Elixir like "Hands-on Elixir & OTP: Cryptocurrency trading bot" series.
    • Meet Elixir - Walk through some features and concepts of Elixir by José Valim.

  • Websites

  • Natural Language Processing (NLP)

    • Tongue - Elixir port of Nakatani Shuyo's natural language detector.
    • gibran - Gibran is an Elixir port of [WordsCounted](https://github.com/abitdodgy/words_counted), a natural language processor that extracts useful statistics from text.
    • Paasaa - Natural language detection for Elixir.
    • Petrovich - Elixir library to inflect Russian first, last, and middle names.
    • Woolly - Woolly is an ambitious Text Mining and Natural Language Processing API for Elixir.

  • PDF

    • gutenex - Native PDF generation for Elixir.
    • chromic_pdf - A client for Chrome's DevTools API to generate PDFs (HTML to PDF).
    • gutenex - Native PDF generation for Elixir.
    • pdf2htmlex - Convert PDF docs to beautiful HTML files without losing text or format.
    • pdf_generator - A simple wrapper for wkhtmltopdf or puppeteer (HTML to PDF) for use in Elixir projects.
    • puppeteer_pdf - Another wrapper around puppeteer (HTML to PDF) for use in Elixir projects.

  • REST and API

    • accent - Plug for handling the conversion of JSON API keys to different cases.
    • maru - Elixir copy of grape for creating REST-like APIs.
    • accent - Plug for handling the conversion of JSON API keys to different cases.
    • detergent - An emulsifying Erlang SOAP library.
    • detergentex - Elixir binding to Detergent erlang library used to call WSDL/SOAP Services.
    • mazurka - Hypermedia API toolkit.
    • plug_rest - REST behaviour and Plug router for hypermedia web applications.
    • signaturex - Simple key/secret based authentication for APIs.
    • SOAP client - Hex-documented SOAP client based on HTTPoison.
    • urna - Urna is a simple DSL around cauldron to implement REST services.
    • versionary - API versioning for Elixir Plug and Phoenix.

  • Static Page Generation

    • medusa - Elixir static site generator that supports Pug.
    • blogit - An OTP application for generating blogs from git repositories containing markdown files.
    • coil - Minimalistic static content engine.
    • glayu - A static site generator for mid-sized sites.
    • medusa - Elixir static site generator that supports Pug.
    • NimblePublisher - Minimal filesystem-based publisher with markdown and syntax highlighting.
    • obelisk - Static blog and website generator.
    • pardall_markdown - Reactive publishing framework, filesystem-based with support for Markdown, nested hierarchies, and instant content rebuilding.
    • phoenix_pages - Add blogs, documentation, and other static pages to Phoenix apps.
    • serum - A simple static website generator written in Elixir.

  • Statistics

    • mtx - MTX supports front-end API for tracking Histogram, Meter, Counter, Gauge, Timing keys.
    • descriptive_statistics - Descriptive Statistics for Elixir.
    • mtx - MTX supports front-end API for tracking Histogram, Meter, Counter, Gauge, Timing keys.
    • numerix - A collection of useful mathematical functions with a slant towards statistics, linear algebra and machine learning.
    • simple_stat_ex - Ecto compatible library for simple stat keeping by time period.
    • statistics - Some basic statistical functions for Elixir.

  • Testing

    • definject - Unobtrusive dependency injector for Elixir.
    • dummy - An Elixir mocking library that makes sense by exposing meck in the right way.
    • ex_machina - Flexible test factories for Elixir. Works out of the box with Ecto and Ecto associations.
    • faker - Faker is a pure Elixir library for generating fake data.
    • mix_test_interactive - Interactive test runner for mix test with watch mode.
    • proper - PropEr (PROPerty-based testing tool for ERlang) is a QuickCheck-inspired open-source property-based testing tool for Erlang.
    • test_that_json - JSON assertions and helpers for your Elixir testing needs.
    • wallaby - Wallaby helps test your web applications by simulating user interactions concurrently and manages browsers.
    • white_bread - Story based BDD in Elixir using the gherkin syntax.
    • amrita - A polite, well mannered and thoroughly upstanding testing framework for Elixir.
    • apocryphal - Swagger based document driven development for ExUnit.
    • blacksmith - Data generation framework for Elixir.
    • blitzy - A simple HTTP load tester in Elixir.
    • bypass - Bypass provides a quick way to create a mock HTTP server with a custom plug.
    • chaperon - An HTTP service performance & load testing framework written in Elixir.
    • chemistry - Testing Framework for Elixir.
    • cobertura_cover - Writes a coverage.xml from `mix test --cover` file compatible with Jenkins' Cobertura plugin.
    • double - Create stub dependencies for testing without overwriting global modules.
    • ecto_it - Ecto plugin with default configuration for repos for testing different ecto plugins with databases.
    • efrisby - A REST API testing framework for erlang.
    • elixir-auto-test - Run test when file is saved using inotify-tools.
    • espec - BDD test framework for Elixir inspired by RSpec.
    • espec_phoenix - ESpec for Phoenix web framework.
    • ex_integration_coveralls - A library for Elixir run-time system code line-level coverage analysis. You can use it to evaluate the integration tests code coverage. [Introduction article](https://github.com/yeshan333/explore_ast_app/blob/main/examples/README.md).
    • ex_parameterized - Simple macro for parameterized testing.
    • ex_spec - BDD-like syntax for ExUnit.
    • ex_unit_fixtures - A library for defining modular dependencies for ExUnit tests.
    • ex_unit_notifier - Desktop notifications for ExUnit.
    • excheck - Property-based testing library for Elixir (QuickCheck style).
    • exkorpion - A BDD library for Elixir developers.
    • factory_girl_elixir - Minimal implementation of Ruby's factory_girl in Elixir.
    • fake_server - FakeServer is an HTTP server that simulates response and makes testing external APIs easier.
    • faker - Faker is a pure Elixir library for generating fake data.
    • faker_elixir - FakerElixir is an Elixir package that generates fake data for you.
    • fqc - FiFo Quickcheck helper, a set of helpers for running EQC.
    • gimei - Gimei is a pure Elixir library for generating Japanese fake data.
    • hound - Elixir library for writing integration tests and browser automation.
    • hypermock - HTTP request stubbing and expectation Elixir library.
    • ignorant - Partial `Map` comparison that ensures fields are present while ignoring their values.
    • katt - KATT (Klarna API Testing Tool) is an HTTP-based API testing tool for Erlang.
    • kovacs - A simple ExUnit test runner.
    • markdown_test - A library that lets you test the Elixir code in your markdown files.
    • meck - A mocking library for Erlang.
    • mecks_unit - A package to elegantly mock module functions within (asynchronous) ExUnit tests using [meck](https://github.com/eproxus/meck).
    • mix_erlang_tasks - Common tasks for Erlang projects that use Mix.
    • mix_eunit - A Mix task to execute eunit tests.
    • mix_test_interactive - Interactive test runner for mix test with watch mode.
    • mix_test_watch - Automatically run your Elixir project's tests each time you save a file.
    • mixunit - An EUnit task for Mix based projects.
    • mneme - Assertions that know how to update themselves, otherwise known as snapshot or approval testing.
    • mock - Mocking library for the Elixir language.
    • mockery - Simple mocking library for asynchronous testing.
    • mockingbird - A set of helpers to test code that involves http requests.
    • mox - Mocks and explicit contracts for Elixir.
    • patch - Ergonomic Mocking for Elixir.
    • pavlov - BDD framework for your Elixir projects.
    • plug_test_helpers - A simple testing DSL for Plugs.
    • ponos - Ponos is an Erlang application that exposes a flexible load generator API.
    • power_assert - Power Assert in Elixir. Shows evaluation results each expression.
    • propcheck - Property based testing for Elixir.
    • setup_tag - Easily mix and match functions marked with tags to setup your test context.
    • shouldi - Elixir testing libraries with nested contexts, superior readability, and ease of use.
    • stream_data - A pure-Elixir data generation and property-based testing library.
    • test_selector - A set of test helpers that make sure you always select the right elements in your Phoenix app.
    • test_that_json - JSON assertions and helpers for your Elixir testing needs.
    • toxiproxy_ex - API client for the resilience testing tool Toxiproxy.
    • tuco_tuco - TucoTuco helps you test your web application by running a web browser and simulating user interaction with your application.
    • Walkman - Isolate tests from the real world, inspired by Ruby's VCR.
    • dummy - An Elixir mocking library that makes sense by exposing meck in the right way.

  • Text and Numbers

    • base62 - Base62 encoder/decoder in pure Elixir.
    • bencoder - bencode in Elixir.
    • colors - Colors util written in Elixir.
    • faust - Markov Text Generator for Elixir.
    • haikunator - Generate Heroku-like memorable random names to use in your apps or anywhere else.
    • money - Working with Money safer, easier, and fun, interpretation of the Fowler's Money pattern.
    • near_api - A [NEAR](https://near.org) API in Elixir - a library for DApps development on the NEAR blockchain platform.
    • pinyin - Chinese Pinyin lib for Elixir.
    • ref_inspector - Referer parser library in Elixir. Fetching info from URLs.
    • smile - Small lib for converting emoji mappers to emoji characters, like in Slack messages.
    • ua_inspector - User agent parser library like `piwik/device-detector`.
    • abacus - Evaluate math terms in Elixir.
    • base58 - Base58 encoding/decoding for Elixir.
    • base58check - Base58Check encoding/decoding for Bitcoin.
    • base62 - Base62 encoder/decoder in pure Elixir.
    • bencode - A Bencode encoder and decoder for Elixir. The decoder will return the checksum value of the info dictionary, if an info dictionary was found in the input.
    • bencoder - bencode in Elixir.
    • bitcoinex - Bitcoin utilities in Elixir.
    • brcpfcnpj - Number format and Validation for Brazilian documents (CPF/CNPJ).
    • caustic - Elixir cryptocurrency library for Bitcoin, Ethereum, and other blockchains. Includes cryptography, number theory (prime, congruence), and general mathematics library for exploratory math.
    • ccc - Character Code Converter.
    • chinese_translation - Translate between traditional chinese and simplified chinese based on wikipedia data, and translate chinese words/characters to pinyin (or slug with or without tone).
    • cidr - Classless Inter-Domain Routing (CIDR) for Elixir.
    • cirru_parser - Cirru Parser in Elixir.
    • colorful - Elixir macros to decorate characters on CUI.
    • convertat - An Elixir library for converting from and to arbitrary bases.
    • curtail - HTML tag-safe string truncation.
    • custom_base - Allow you to make custom base conversion in Elixir.
    • decimal - Arbitrary precision decimal arithmetic for Elixir.
    • dicer - A dice roller expression evaluator.
    • eden - [EDN](https://github.com/edn-format/edn) encoder/decoder for Elixir.
    • elixilorem - Lorem Ipsum generator for Elixir.
    • elixir-range-extras - Elixir range utilities: constant-time random sampling and set operations.
    • elixir_bencode - Bencode implemented in Elixir.
    • erldn - [EDN](https://github.com/edn-format/edn) format parser for the Erlang platform.
    • event_source_encoder - Encode data into EventSource compliant data.
    • ex_brace_expansion - Brace expansion, as known from sh/bash, in Elixir.
    • ex_cldr - Cldr is an Elixir library for the Unicode Consortium's Common Locale Data Repository (CLDR).
    • ex_pression - Evaluate user input expressions.
    • ex_rfc3966 - Elixir Tel URI parser compatible with RFC3966.
    • ex_rfc3986 - RFC3986 URI/URL parser.
    • ex_uc - Extensible Units Converter for Elixir.
    • exmoji - Emoji encoding Swiss Army knife for Elixir/Erlang.
    • expletive - Profanity filter library for Elixir.
    • expr - An Elixir library for parsing and evaluating mathematical expressions.
    • faust - Markov Text Generator for Elixir.
    • hashids - Hashids lets you obfuscate numerical identifiers via reversible mapping.
    • hexate - Simple module for Hex encoding / decoding in Elixir.
    • inet_cidr - Classless Inter-Domain Routing (CIDR) for Elixir that is compatible with :inet and supports both IPv4 and IPv6.
    • inflex - An Inflector library for Elixir.
    • kitsune - An Elixir library for transforming the representation of data.
    • ltsvex - LTSV parser implementation in Elixir.
    • mbcs - Wrapper for erlang-mbcs. This module provides functions for character encoding conversion.
    • mimetype_parser - parse mimetypes.
    • minigen - Random data generators for the Erlang ecosystem.
    • monetized - A lightweight solution for handling and storing money.
    • money - Working with Money safer, easier, and fun, interpretation of the Fowler's Money pattern.
    • mt940 - MT940 (standard structured SWIFT Customer Statement message) parser for Elixir.
    • namor - A name generator that creates random, url-friendly slugs.
    • nanoid - Elixir port of NanoID, a secure and URL-friendly unique ID generator.
    • near_api - A [NEAR](https://near.org) API in Elixir - a library for DApps development on the NEAR blockchain platform.
    • neotomex - A [PEG](http://bford.info/packrat/) implementation with a pleasant Elixir DSL.
    • number - Number is a pretentiously-named Elixir library which provides functions to convert numbers into a variety of different formats.
    • numero - A micro library for converting non-english utf-8 digits in elixir.
    • palette - A handy library for colouring strings in Elixir.
    • pinyin - Chinese Pinyin lib for Elixir.
    • porterstemmer - Porter Stemmer in Elixir.
    • pretty_hex - A binary hex dumping library in Elixir.
    • quickrand - Quick Random Number Generation.
    • RandomStringGenerator - A module to generate a random string based on a given string pattern.
    • ref_inspector - Referer parser library in Elixir. Fetching info from URLs.
    • remove_emoji - Emoji text sanitizer in Elixir. It can remove any emoji symbol.
    • secure_random - Convenience library for random base64 strings modeled after my love for Ruby's SecureRandom.
    • sentient - Simple sentiment analysis based on the AFINN-111 wordlist.
    • shortuuid - Generate concise, unambiguous, URL-safe UUIDs.
    • simetric - String similarity metrics for Elixir.
    • slugger - Slugger can generate slugs from given strings that can be used in URLs or file names.
    • smile - Small lib for converting emoji mappers to emoji characters, like in Slack messages.
    • stemmer - An English (Porter2) stemming implementation in Elixir.
    • tau - Provide the famous mathematical constant, tau, τ = 6.2831....
    • tomlex - A TOML parser for Elixir.
    • transformer - Flexible type conversion lightweight library.
    • ua_inspector - User agent parser library like `piwik/device-detector`.
    • ua_parser2 - A port of ua-parser2 to Elixir. User agent parser library.
    • unique_names_generator - Generate seeded random and unique names.
    • unit_fun - Attempt to add units to numbers in elixir to give some added type safety when dealing with numeric quantities.
    • uuid - UUID generator and utilities for Elixir.
    • uuid_erl - Erlang Native UUID Generation.
    • veritaserum - Sentiment analysis based on afinn-165, emojis and some enhancements.

  • Utilities

    • plasm - Plasm is Ecto's composable query multitool, containing higher-level functions such as .count, .random, .first, .last, .find, .inserted_before, .inserted_after, etc.
    • quark - A library for common functional programming idioms: combinators, currying, and partial application.
    • sips_downloader - Elixir module for downloading the ElixirSips episodes and all other files.
    • sitemapper - A fast, stream based XML Sitemap generator.
    • ar2ecto - Ar2ecto is a set of mix tasks to help you migrate from ActiveRecord to Ecto.
    • async_with - A modifier for Elixir's "with" to execute all its clauses in parallel.
    • crutches - Utility library for Elixir, designed to complement the standard library bundled with the language.
    • deppie - Elixir's coolest deprecation logger.
    • dot-notes - Simple dot/bracket notation parsing/conversion for Maps/Lists.
    • dress - Cli app that makes your stdout fancy.
    • erlang-history - Hacks to add shell history to Erlang's shell.
    • erlsh - Family of functions and ports involving interacting with the system shell, paths and external programs.
    • erlware_commons - Additional standard library for Erlang.
    • ex_progress - A library for tracking progress across many tasks and sub-tasks.
    • exjprop - Elixir library for reading Java properties files from various sources.
    • fitex - FitEx is a Macro-Module which provides a bit of sugar for function definitions.
    • global - Wrapper of the Erlang `:global` module.
    • mandrake - Mandrake is a functional programming library that bring something else magic in elixir.
    • mnemonix - A unified interface to key/value stores.
    • plasm - Plasm is Ecto's composable query multitool, containing higher-level functions such as .count, .random, .first, .last, .find, .inserted_before, .inserted_after, etc.
    • plugmap - Plugmap is sitemap generation library for Plug/Phoenix Framework.
    • pubsub - A Publish-Subscribe utility library that implements a pub-sub mechanism to ease the burden of communication on the business logic processes.
    • retry - Simple Elixir macros for linear retry, exponential backoff and wait with composable delays.
    • sips_downloader - Elixir module for downloading the ElixirSips episodes and all other files.
    • sitemap - Sitemap is the easiest way to generate Sitemaps in Elixir.
    • sitemapper - A fast, stream based XML Sitemap generator.
    • uef-lib - Useful Erlang Functions Library that provides modules for manipulating lists, binaries, maps, numbers, date and time. It contains some functions optimized for performance in specific cases (e.g. for file I/O operations or binary transformations).
    • vert.x - Elixir event bus bridge to Vert.x services using TCP socket.

  • Validations

    • exop - A library that allows to encapsulate business logic and validate params with predefined contract.
    • skooma - Simple data validation library for describing and validating data structures.
    • bankster - A IBAN account number and BIC validation library for Elixir.
    • ex_gtin - A validation library for GTIN codes under GS1 specification.
    • ex_nric - Validation for Singapore National Registration Identity Card numbers (NRIC).
    • form - Document forms and validation library.
    • goal - A parameter validation library for LiveViews and JSON/HTML controllers - based on Ecto.
    • is - Fast, extensible and easy to use data structure validation for elixir with nested structures support.
    • jeaux - A light and easy schema validator.
    • optimal - A schema based keyword list option validator.
    • shape - A data validation library for Elixir based on Prismatic Scheme.
    • skooma - Simple data validation library for describing and validating data structures.
    • uk_postcode - UK postcode parsing and validation library.
    • vex - An extensible data validation library for Elixir.
    • voorhees - A library for validating JSON responses.

  • Version Control

    • gitex - Elixir implementation of the Git object storage, but with the goal to implement the same semantic with other storage and topics.
    • gitex - Elixir implementation of the Git object storage, but with the goal to implement the same semantic with other storage and topics.

  • WebAssembly

    • lumen - An alternative BEAM implementation, designed for WebAssembly.
    • lumen - An alternative BEAM implementation, designed for WebAssembly.
    • wasmex - Execute WebAssembly / WASM binaries from Elixir.

  • XML

    • sweet_xml - Query XML simply and effectively.
    • elixir-map-to-xml - Converts an Elixir map to an XML document.
    • elixir-xml-to-map - Creates an Elixir Map data structure from an XML string.
    • erlsom - Erlsom is an Erlang library to parse (and generate) XML documents.
    • exmerl - Elixir wrapper for xmerl.
    • exml - Most simple Elixir wrapper for xmerl xpath.
    • exoml - A module to decode/encode xml into a tree structure.
    • fast_xml - Fast Expat based Erlang XML parsing library.
    • quinn - XML parser for Elixir.
    • saxy - Saxy is an XML parser and encoder in Elixir that focuses on speed and standard compliance.
    • sweet_xml - Query XML simply and effectively.
    • xml_builder - Elixir library for generating xml.
    • xmlrpc - Library for encoding and decoding XML-RPC for clients and servers.
    • meeseeks - A library for parsing and extracting data from HTML and XML with CSS or XPath selectors.

  • Actors

    • bpe - Business Process Engine in Erlang. ([Doc](https://bpe.n2o.dev)).
    • pooler - An OTP Process Pool Application.
    • alf - Flow-based Application Layer Framework.
    • poolex - Pure elixir pool manager.
    • spawn - Elixir poliglot actors service mesh.
    • pooler - An OTP Process Pool Application.

  • Applications

    • ExShop - Digital goods shop & blog created using Phoenix framework.
    • medusa_server - A simple cowboy web server written in Elixir to stack images. ([Docs](https://hexdocs.pm/medusa/0.2.0/api-reference.html)).
    • Tai - A composable, real time, cryptocurrency market data and trade execution toolkit.
    • Caddishouse - A web-based document reader that connects to your cloud storage accounts using Phoenix/LiveView.
    • CaptainFact - A collaborative, real-time video fact-checking platform. ([Docs](https://captainfact.io/)).
    • chat - A tiny text chat sample based on N2O.
    • Consolex - Consolex is a tool that allows you to attach a web based console to any mix project.
    • dragonfly_server - Elixir app to serve Dragonfly images.
    • exchat - A Slack-like app by Elixir, Phoenix & React (redux).
    • Exon - A “mess manager” developed in Elixir and provides a simple API to manage & document your stuff. ([Docs](https://hexdocs.pm/exon/readme.html)).
    • ExShop - Digital goods shop & blog created using Phoenix framework.
    • Hydra - A multi-headed beast: API gateway, request cache, and data transformations.
    • Igthorn - Cryptocurrecy trading platform / trading bot with admin panel.
    • majremind - A self-maintained database of your updated server which tells you which one needs to be updated.
    • medex - Medical Examination - application for register health check callbacks and represent their state via HTTP.
    • Nvjorn - A multi-protocol network services monitor written in Elixir using Poolboy.
    • Phoenix Battleship - The Good Old game built with Elixir, Phoenix Framework, React and Redux.
    • Phoenix Toggl - Toggl tribute done in Elixir, Phoenix Framework, React and Redux.
    • Tai - A composable, real time, cryptocurrency market data and trade execution toolkit.
    • Phoenix Trello - Trello tribute done in Elixir, Phoenix Framework, React and Redux.
    • Plural - Deploys your favorite open source applications like airflow and airbyte in your own cloud account with just two commands. Written in Elixir and Phoenix Framework for server side, and React for frontend.
    • poxa - Open Pusher implementation, compatible with Pusher libraries.
    • Queerlink - A simple yet efficient URL shortening service written in Elixir.
    • RemoteRetro - A real-time application for conducting Agile retrospectives at [remoteretro.org](https://remoteretro.org) written in Elixir/Phoenix/React.
    • Sprint Poker - Online estimation tool for Agile teams, written using Elixir Lang, Phoenix Framework and React.
    • Startup Job - An umbrella project to search startup jobs scraped from websites written in Elixir/Phoenix and React/Redux.
    • tty2048 - Terminal-based 2048 game written in Elixir.
    • uai_shot - A multiplayer ship game built with Elixir, Phoenix Framework and Phaser.
    • utils - Website with handy day-to-day utils: to do list, URL shortener, code bin and pie chart. Written in Elixir using Phoenix Framework.
    • workbench - From Idea to Execution - Manage your trading operation across a globally distributed cluster.
    • Lynx - A Fast, Secure and Reliable Terraform Backend, Set up in Minutes.

  • Behaviours and Interfaces

    • connection - Connection behaviour for connection processes. The API is superset of the GenServer API.
    • gen_state_machine - Elixir wrapper for gen_statem.
    • stockastic - Simple Elixir wrapper for the Stockfighter API.
    • connection - Connection behaviour for connection processes. The API is superset of the GenServer API.
    • gen_state_machine - Elixir wrapper for gen_statem.
    • stockastic - Simple Elixir wrapper for the Stockfighter API.

  • Benchmarking

    • benchee - Easy and extensible benchmarking in Elixir.
    • beamchmark - A Tool for measuring EVM performance.
    • benchfella - Benchmarking tool for Elixir.
    • bmark - A benchmarking tool for Elixir.

  • Bittorrent

    • tracker_request - Dealing with bittorrent tracker requests and responses.
    • wire - Encode and decode bittorrent peer wire protocol messages with Elixir.
    • bento - An incredibly fast, correct, pure-Elixir Bencoding library.
    • wire - Encode and decode bittorrent peer wire protocol messages with Elixir.

  • BSON

    • cyanide - An Elixir BSON encoding/decoding library.
    • BSONMap - Elixir package that applies a function to each document in a BSON file and has a low memory consumption.
    • cyanide - An Elixir BSON encoding/decoding library.

  • Build Tools

    • active - Recompilation and Reloading on FileSystem changes.
    • reaxt - React template into your Elixir application for server rendering.
    • rebar3_neotoma_plugin - Rebar3 neotoma (Parser Expression Grammar) compiler.
    • active - Recompilation and Reloading on FileSystem changes.
    • coffee_rotor - Rotor plugin to compile CoffeeScript files.
    • dismake - Mix compiler running make.
    • etude - Parallel computation coordination compiler for Erlang/Elixir.
    • ExMake - A modern, scriptable, dependency-based build tool loosely based on Make principles.
    • Exscript - Elixir escript library.
    • mad - Small and Fast Rebar Replacement.
    • pc - A rebar3 port compiler.
    • reaxt - React template into your Elixir application for server rendering.
    • rebar3_abnfc_plugin - Rebar3 abnfc compiler.
    • rebar3_asn1_compiler - Plugin for compiling ASN.1 modules with Rebar3.
    • rebar3_auto - Rebar3 plugin to auto compile and reload on file change.
    • rebar3_diameter_compiler - Compile diameter .dia files in rebar3 projects.
    • rebar3_eqc - A rebar3 plugin to enable the execution of Erlang QuickCheck properties.
    • rebar3_exunit - A plugin to run Elixir ExUnit tests from rebar3 build tool.
    • rebar3_idl_compiler - This is a plugin for compiling Erlang IDL files using Rebar3.
    • rebar3_live - Rebar3 live plugin.
    • rebar3_neotoma_plugin - Rebar3 neotoma (Parser Expression Grammar) compiler.
    • rebar3_protobuffs - rebar3 protobuffs provider using protobuffs from Basho.
    • rebar3_run - Run a release with one simple command.
    • rebar3_yang_plugin - Rebar3 yang compiler.
    • reltool_util - Erlang reltool utility functionality application.
    • relx - A release assembler for Erlang.
    • remix - Automatic recompilation of Mix code on file change.
    • rotor - Super-simple build system for Elixir.
    • sass_elixir - A sass plugin for Elixir projects.

  • Caching

    • gen_spoxy - Caching made fun.
    • cachex - A powerful caching library for Elixir with a wide featureset.
    • con_cache - ConCache is an ETS based key/value storage.
    • elixir_locker - Locker is an Elixir wrapper for the locker Erlang library that provides some useful libraries that should make using locker a bit easier.
    • gen_spoxy - Caching made fun.
    • jc - In-memory, distributable cache with pub/sub, JSON-query and consistency support.
    • locker - Atomic distributed "check and set" for short-lived keys.
    • lru_cache - Simple LRU Cache, implemented with ets.
    • memoize - A memoization macro that easily cache function.
    • nebulex - A fast, flexible and extensible distributed and local caching library for Elixir.
    • request_cache_plug - Easy to use caching for requests in either Phoenix Controllers or GraphQL resolvers. Bypasses JSON encoding/decoding for a large speedup.
    • stash - A straightforward, fast, and user-friendly key/value store.

  • CSV

    • nimble_csv - A simple and fast CSV parsing and dumping library for Elixir.
    • cesso - CSV handling library for Elixir.
    • csv - CSV Decoding and Encoding for Elixir.
    • csv2sql - A fast and fully automated CSV to database importer.
    • csvlixir - A CSV reading/writing application for Elixir.
    • ecsv - Fast libcsv-based stream parser for Elixir.
    • ex_csv - CSV for Elixir.

  • Debugging

    • booter - Boot an Elixir application, step by step.
    • beaker - Statistics and Metrics library for Elixir.
    • dbg - Distributed tracing for Elixir.
    • eflame - Flame Graph profiler for Erlang.
    • eper - Erlang performance and debugging tools.
    • ether - Ether provides functionality to hook Elixir into the Erlang debugger.
    • ex_debug_toolbar - A toolbar for Phoenix projects to interactively debug code and display useful information about requests: logs, timelines, database queries etc.
    • exrun - Distributed tracing for Elixir with rate limiting and simple macro-based interface.
    • extrace - Elixir wrapper for Recon Trace.
    • git_hooks - Add git hooks to Elixir projects.
    • inspector - A simple one-line module that allows a more friendly debugging experience.
    • observer_cli - Visualize Elixir & Erlang nodes on the command line, it aims to help developers debug production systems.
    • quaff - The Debug module provides a simple helper interface for running Elixir code in the erlang graphical debugger.
    • rexbug - An Elixir wrapper for the `redbug` production-friendly Erlang tracing debugger.
    • visualixir - A process visualizer for remote BEAM nodes.

  • Domain-specific language

    • JSON-LD.ex - An implementation of the [JSON-LD](http://www.w3.org/TR/json-ld/) standard for [RDF.ex](https://github.com/marcelotto/rdf-ex).
    • RDF.ex - An implementation of the [RDF](https://www.w3.org/TR/rdf11-primer/) data model in Elixir.
    • SPARQL.ex - An implementation of the [SPARQL](http://www.w3.org/TR/sparql11-overview/) standards in Elixir.
    • Absinthe Graphql - Fully featured GraphQL library.
    • absinthe_gen - Scaffold generator for Absithne.

  • ECMAScript

    • estree - A implementation of the SpiderMonkey Parser API in Elixir.
    • phoenix_gon - Allow you to pass Phoenix environment or controller variables to JavaScript without problems.
    • phoenix_routes_js - Phoenix routes helpers in JavaScript code and browser console.

  • Examples and funny stuff

    • stranger - Elixir Phoenix app to chat anonymously with a randomly chosen stranger.
    • butler_cage - A Butler plugin for showing silly photos of Nick Cage.
    • butler_tableflip - Flipping tables with butler.
    • changelog.com - CMS that runs changelog.com built with Phoenix 1.4.
    • coderplanets.com - GraphQL api for coderplanets.com built with Phoenix 1.4 and Absinthe.
    • dice - Roll the dice, in Elixir.
    • elixir_koans - [Elixir koans](http://elixirkoans.io/) is a fun, easy way to get started with the elixir programming language.
    • ex_chain - Simple Markov Chain that generates funny tweets, built using Elixir.
    • feedx - Add social feed functionality to current applications. Exemplify OTP umbrella app, with 3 apps. Thin phoenix controllers.
    • harakiri - Help applications kill themselves.
    • hello_phoenix - Application template for SPAs with Phoenix, React and Redux.
    • hexpm - Source code for the hex package manager site built with Phoenix 1.3.
    • kaisuu - Watch Japan's Kanji Usage on Twitter in Realtime.
    • koans - Learn Elixir by using elixir-koans.
    • lolcat - This is the clone of busyloop/lolcat. But it does not support animation and some features of the original.
    • magnetissimo - Web application that indexes all popular torrent sites, and saves it to the local database.
    • oop - OOP in Elixir.
    • phoenix-chat-example - A step-by-step example/tutorial for building a Chat app in Phoenix for complete beginners. Covers testing, docs and deployment. Phoenix `1.5.3`.
    • phoenix-ecto-encryption-example - A comprehensive example/tutorial showing people how to use Ecto Types to transparently encrypt/decrypt data in a Phoenix 1.4 app.
    • phoenix-flux-react - An experiment with Phoenix Channels, GenEvents, React and Flux.
    • phoenix-liveview-counter-tutorial - complete beginners step-by-step tutorial building a real time counter in Phoenix `1.5.3` and LiveView `0.14.1`.
    • phoenix-todo-list-tutorial - A complete beginners step-by-step tutorial for building a Todo List from scratch in Phoenix `1.5.3`.
    • portal - A shooting fault-tolerant doors for distributed portal data-transfer application in Elixir.
    • real world example app - Elixir / Phoenix implementation of [RealWorld.io](https://realworld.io/) backend specs - a Medium clone.
    • rollex - Elixir library using a Pratt Parser algorithm to calculate dice rolls.
    • rubix - A very simple (and barely-functioning) Ruby runner for Elixir.
    • tilex - Source code for Hashrocket's TIL website built with Phoenix 1.3.
    • weather - A command line weather app built using Elixir.

  • Geolocation

    • geo - A collection of GIS functions for Elixir.
    • geocoder - A simple, efficient geocoder/reverse geocoder with a built-in cache.
    • geolix - MaxMind GeoIP2 database reader/decoder.
    • distance_api_matrix - Provide distance and heading calculations via Google distance matrix api.
    • geocalc - Calculate distance, bearing and more between latitude/longitude points.
    • geocoder - A simple, efficient geocoder/reverse geocoder with a built-in cache.
    • geohash - Geohash encode/decode library.
    • geohax - Geohash encoding and decoding with neighbors finder.
    • geoip - Find geolocation for a given IP, hostname or `Plug.Conn`.
    • geolix - MaxMind GeoIP2 database reader/decoder.
    • geonames - A simple Elixir wrapper around the GeoNames API.
    • ip2location - An Elixir library for IP2Location database.
    • ipgeobase - Find Russian and Ukraine city by IP address and find country for other country.
    • proj - Elixir coordinate conversion library using OSGeo's PROJ.4.
    • segseg - Segment-segment intersection classifier and calculator.
    • srtm - Query locations for elevation data from the NASA Shuttle Radar Topography Mission.
    • topo - A Geometry library for Elixir that calculates spatial relationships between two geometries.
    • wheretz - Elixir version of Ruby gem for lookup of timezone by georgraphic coordinates.

  • GUI

    • scenic - Portable 2D UI framework.
    • scenic - Portable 2D UI framework.

  • JSON

    • ja_serializer - JSONAPI.org Serialization in Elixir.
    • joken - Encodes and decodes JSON Web Tokens.
    • jsonapi - A project that will render your data models into [JSONAPI Documents](http://jsonapi.org/format/).
    • exjson - JSON parser and generator in Elixir.
    • jason - A blazing fast JSON parser and generator in pure Elixir.
    • jazz - Yet another library to handle JSON in Elixir.
    • jose - JSON Object Signing and Encryption (JOSE) for Erlang and Elixir.
    • json - Native JSON library for Elixir.
    • json_pointer - Implementation of RFC 6901 which defines a string syntax for identifying a specific value within a JSON document.
    • json_stream_encoder - JsonStreamEncoder is a streaming encoder for streaming JSON to an IOish thing in Elixir.
    • json_web_token_ex - An Elixir implementation of the JSON Web Token (JWT) Standards Track (RFC 7519).
    • jsonc - Utilities for working with [jsonc](https://komkom.github.io/jsonc-playground), a superset of json.
    • jsx - An Erlang application for consuming, producing, and manipulating json.
    • jsxn - jsx but with maps.
    • jwalk - Helper module for working with Erlang representations of JSON.
    • jwtex - A library to encode and decode [JWT tokens](http://jwt.io/).
    • poison - Poison is a new JSON library for Elixir focusing on wicked-fast speed without sacrificing simplicity, completeness, or correctness.
    • tiny - Tiny, fast and fully compliant JSON parser for Elixir.
    • world_json - topojson country and state/province collections for elixir/erlang.

  • Lexical analysis

    • lex_luthor - LexLuthor is a Lexer in Elixir which uses macros to generate a reusable lexers.
    • abnf_parsec - ABNF in and parser out.
    • ex_abnf - Parser for ABNF Grammars in Elixir.

  • Macros

    • crudry - Crudry is an elixir library for DRYing CRUD of Phoenix Contexts and Absinthe Resolvers.
    • rulex - Simple rule handler using Elixir pattern matching.
    • anaphora - Anaphora is the anaphoric macro collection for Elixir. An anaphoric macro is one that deliberately captures a variable (typically it) from forms supplied to the macro.
    • apix - Simple convention and DSL for transformation of elixir functions to an API for later documentation and or validation.
    • backports - Use new functions in Elixir 1.1 and 1.2.
    • crudry - Crudry is an elixir library for DRYing CRUD of Phoenix Contexts and Absinthe Resolvers.
    • eventsourced - Build functional, event-sourced domain models.
    • expat - Reusable, composable patterns across Elixir libraries.
    • guardsafe - Macros expanding into code that can be safely used in guard clauses.
    • kwfuns - Macros to create functions with syntax based keyword parameters with default values.
    • lineo - parse transform for accurate line numbers.
    • matcha - First-class match specifications for Elixir `:ets` querying and function call tracing.
    • mdef - Easily define multiple function heads in Elixir.
    • named_args - Allows named arg style arguments in Elixir.
    • ok_jose - Pipe elixir functions that match `{:ok,_}`, `{:error,_}` tuples or custom patterns.
    • opus - A framework for pluggable business logic components.
    • pathex - Zero-dependency, blazing fast functional lenses.
    • pattern_tap - Macro for tapping into a pattern match while using the pipe operator.
    • pipe_here - Easily pipe values into any argument position.
    • pipe_to - The enhanced pipe operator which can specify the target position.
    • pipes - Macros for more flexible composition with the Elixir Pipe operator.
    • pit - Transform values as they flow inside a pipe.
    • rebind - rebind parse transform for Erlang.
    • shorter_maps - ~M sigil for map shorthand. `~M{id name} ~> %{id: id, name: name}`.
    • typed_struct - An Elixir library for defining structs with a type without writing boilerplate code.
    • unsafe - Generate easy unsafe (!) bindings for Elixir functions.
    • typed_structor - A library for defining structs with types effortlessly.

  • Cheat Sheets

  • Audio and Sounds

    • erlaudio - Erlang PortAudio bindings.
    • ex_alsa - Elixir ALSA bindings.
    • ex_jack - Elixir JACK bindings.
    • firmata - This package implements the Firmata protocol.
    • synthex - A signal synthesis library.

  • Authorization

    • authorize - Rule based authorization, for advanced authorization rules.
    • bodyguard - A flexible authorization library for Phoenix applications.
    • canada - A simple authorization library that provides a friendly interface using declarative permission rules.
    • canary - An authorization library for Elixir applications that restricts what resources the current user is allowed to access. ([Docs](https://hexdocs.pm/canary/api-reference.html)).
    • speakeasy - Middleware based authentication and authorization for Absinthe GraphQL powered by Bodyguard.
    • terminator - Database based authorization (ACL), with custom DSL rules for requiring needed permissions. ([Docs](https://hexdocs.pm/terminator/readme.html)).

  • Chatting

    • alice - A Slack bot framework for Elixir.
    • chatty - A basic IRC client that is most useful for writing a bot.
    • cog - Cog is an open chatops platform that gives you a secure, collaborative command line right in your chat window.
    • ExGram - a library to build Telegram Bots, you can use the low-level methods and models or use the really opinionated framework included. ([Docs](https://hexdocs.pm/ex_gram/readme.html)).
    • ExIrc - IRC client adapter for Elixir projects.
    • ExMustang - A simple, clueless slackbot and collection of responders.
    • Guri - Automate tasks using chat messages.
    • hedwig - XMPP Client/Bot Framework for Elixir.([Docs](https://hexdocs.pm/hedwig/readme.html)).
    • hipchat_elixir - HipChat client library for Elixir, based on httpc.
    • kaguya - A small, powerful, and modular IRC bot.
    • slacker - A bot library for the Slack chat service.
    • yocingo - Create your own Telegram Bot.

  • Configuration

    • confex - Helper module that provides a nice way to read environment configuration at runtime.
    • configparser_ex - A simple Elixir parser for the same kind of files that Python's configparser library handles.
    • conform - Easy release configuration for Elixir apps.
    • dotenv - A port of dotenv to Elixir.
    • enux - utility package for loading, validating and documenting your app's configuration variables from env, json and jsonc files at runtime and injecting them into your environment.
    • ex_conf - Simple Elixir Configuration Management.
    • figaro - Simple Elixir project configuration.
    • figaro_elixir - Environmental variables manager for Elixir.
    • hush - Read and inject configuration at runtime, and in release mode with support for multiple providers.
    • hush_aws_secrets_manager - AWS Secrets Manager provider for hush.
    • hush_gcp_secret_manager - Google Secret Manager provider for hush.
    • mahaul - Supercharge your environment variables in Elixir. Parse and validate with compile time access guarantees, defaults, fallbacks and app pre-boot validations.
    • skogsra - Library to manage OS environment variables and application configuration options with ease.
    • sweetconfig - Read YAML configuration files from any point at your app.
    • weave - JIT configuration loader that works with Kubernetes and Docker Swarm.

  • Cryptography

    • aescmac - AES CMAC ([RFC 4493](https://tools.ietf.org/html/rfc4493)) in Elixir.
    • cipher - Elixir crypto library to encrypt/decrypt arbitrary binaries.
    • cloak - Cloak makes it easy to use encryption with Ecto.([Docs](https://hexdocs.pm/cloak/readme.html)).
    • comeonin - Password hashing (argon2, bcrypt, pbkdf2_sha512) library for Elixir.([https://hexdocs.pm/comeonin/api-reference.html](https://hexdocs.pm/comeonin/api-reference.html)).
    • crypto_rsassa_pss - RSASSA-PSS Public Key Cryptographic Signature Algorithm for Erlang.
    • elixir_tea - TEA implementation in Elixir.
    • ex_bcrypt - Elixir wrapper for the OpenBSD bcrypt password hashing algorithm.
    • ex_crypto - Elixir wrapper for Erlang `crypto` and `public_key` modules. Provides sensible defaults for many crypto functions to make them easier to use.([Docs](https://hexdocs.pm/ex_crypto/readme.html)).
    • exgpg - Use gpg from Elixir.
    • nimble_totp - Allows implementation of Time-based One-Time Passwords (TOTP) for 2FA.
    • ntru_elixir - Elixir wrapper for libntru. A post quantum cryptography system.
    • pot - Erlang library for generating one time passwords compatible with Google Authenticator.
    • rsa - `public_key` cryptography wrapper for Elixir.
    • rsa_ex - Library for working with RSA keys.
    • siphash-elixir - Elixir implementation of the SipHash hash family.
    • tea_crypto - Tiny Encryption Algorithm implementation.

  • Errors and Exception Handling

    • AppSignal Elixir - The official [AppSignal](https://appsignal.com/) package for Elixir.
    • elixir_error_message - Simple error helpers to make errors in your system predictable and easy to render to JSON or in logs.
    • exceptional - Helpers for happy-path programming & exception handling.
    • happy - Happy path programming, alternative to elixir `with` form.
    • OK - Elegant error handling with result monads, featuring a simple & powerful `with` construct and a happy path pipe operator.
    • sentry-elixir - The Official Elixir client for [Sentry](https://sentry.io/).

  • Feature Flags and Toggles

    • ConfigCat - Elixir SDK for ConfigCat hosted feature flag service.
    • flippant - Feature flipping for the Elixir world.
    • fun_with_flags - A feature toggle library using Redis or Ecto for persistence, an ETS cache for speed and PubSub for distributed cache busting. Comes with a management web UI for Phoenix and Plug.
    • molasses - A feature toggle library using redis or SQL (using Ecto) as a backing service.

  • Feeds

    • atomex - ATOM feed builder with a focus on standards compliance, security and extensibility.
    • feeder - Parse RSS and Atom feeds.
    • feeder_ex - RSS feed parser. Simple wrapper for feeder.
    • feedme - RSS/Atom parser built on erlang's xmerl xml parser.

  • Hardware

    • elixir_ale - Elixir access to hardware I/O interfaces such as GPIO, I2C, and SPI.
    • nerves - Framework for building firmware for platforms like Raspberry Pi and BeagleBone Black.

  • HTML

    • floki - A simple HTML parser that enables searching using CSS like selectors.
    • html_sanitize_ex - HTML sanitizer for Elixir.
    • modest_ex - A library to do pipeable transformations on html strings with CSS selectors, e.g. find(), prepend(), append(), replace() etc.
    • myhtmlex - Elixir/Erlang bindings for lexborisov's myhtml.
    • readability - Readability is for extracting and curating articles.
    • texas - Texas is a powerful abstraction over updating your clients using server-side rendering and server-side Virtual DOM diff/patching.
    • tidy_ex - Elixir binding to the granddaddy of HTML tools [http://www.html-tidy.org](http://www.html-tidy.org).
    • vnu-elixir - Elixir client for the [Nu HTML Checker](https://validator.w3.org/nu/). Provides HTML, CSS, and SVG validation.

  • Instrumenting / Monitoring

    • prometheus-phoenix - Phoenix instrumenter for prometheus.ex.
    • app_optex - Client for AppOptics API. Send metrics and tags to AppOptics time series service.
    • elixometer - A light Elixir wrapper around exometer.
    • erlang-metrics - A generic interface to different metrics systems in Erlang.
    • exometer - Basic measurement objects and probe behavior in Erlang.
    • folsom_ddb - DalmatinerDB backend to store folsom metrics.
    • graphitex - Graphite/Carbon client for Elixir.
    • instream - InfluxDB driver for Elixir.
    • instrumental - An Elixir client for [Instrumental](https://instrumentalapp.com/).
    • newrelic.ex - Collects metrics from your Elixir/Phoenix application and sends them to [NewRelic](https://newrelic.com/).
    • prom_ex - Prometheus metrics and Grafana dashboards for all of your favorite Elixir libraries.
    • prometheus - [Prometheus.io](https://prometheus.io) monitoring system and time series database client in Erlang.
    • prometheus-ecto - Ecto instrumenter for prometheus.ex.
    • prometheus-plugs - Plugs instrumenters/exporter for prometheus.ex.
    • prometheus.ex - Elixir-friendly [Prometheus.io](https://prometheus.io) monitoring system and time series database client.
    • prometheus_process_collector - Prometheus collector which exports the current state of process metrics including cpu, memory, file descriptor usage and native threads count as well as the process start and up times.
    • spandex - Platform agnostic tracing library originally developed for Datadog APM.
    • telemetry - Dynamic dispatching library for metrics and instrumentations.
    • wobserver - Web based metrics, monitoring, and observer.

  • Languages

    • Elchemy - Compiler allowing to translate Elm programming language code to Elixir.
    • lighthouse_scheme - A small Lisp-like language and interactive REPL, built in Elixir.
    • Monkey - Elixir implementation of an interpreter and REPL for the js-like Monkey programming language.

  • Markdown

    • cmark - Elixir NIF for CommonMark (in C), a parser following the CommonMark spec.
    • discount - Elixir NIF for discount, a Markdown parser.
    • earmark - Markdown parser for Elixir.
    • Markdown - Implemented entirely as a NIF binding to the Hoedown library.
    • Pandex - Lightweight Elixir wrapper for Pandoc. Converts Markdown, CommonMark, HTML, Latex, HTML, HTML5, opendocument, rtf, texttile, asciidoc to each other.

  • Networking

    • asn - Can be used to map from IP to AS to ASN.
    • chatter - Secure message broadcasting based on a mixture of UDP multicast and TCP.
    • download - Download files from the internet easily.
    • eio - Elixir server of engine.io.
    • ExPcap - PCAP parser written in Elixir.
    • Firezone - Open-source VPN server and egress firewall for Linux built on WireGuard. Firezone is easy to set up (all dependencies are bundled thanks to Chef Omnibus), secure, performant, and self hostable.
    • FlyingDdns - A dyndns server written in elixir.
    • hades - A wrapper for NMAP written in Elixir.
    • mac - Can be used to find a vendor of a MAC given in hexadecimal string (according to IEEE).
    • pool - Socket acceptor pool for Elixir.
    • reagent - reagent is a socket acceptor pool for Elixir.
    • sise - A simple to use SSDP client.
    • sockerl - Sockerl is an advanced Erlang/Elixir socket library for TCP protocols and provides fast, useful and easy-to-use API for implementing servers, clients and client connection pools.
    • socket - Socket wrapping for Elixir.
    • sshex - Simple SSH helpers for Elixir.
    • sshkit - An Elixir toolkit for performing tasks on one or more servers, built on top of Erlang’s SSH application.
    • torex - Simple Tor connection library.
    • tunnerl - SOCKS4 and SOCKS5 proxy server.
    • wifi - Various utility functions for working with the local Wifi network in Elixir.
    • wpa_supplicant - Elixir interface to the wpa_supplicant.

  • OTP

    • core - Library for selective receive OTP processes.
    • erlexec - Execute and control OS processes from Erlang/OTP.
    • immortal - Immortal is a small collection of helper modules intended to make it easier to build a fault-tolerant OTP application.
    • libex_config - Helpers for accessing OTP application configuration.

  • QUIC

    • quicer - QUIC protocol erlang library.

  • Release Management

    • changex - Automated changelog generation from GIT logs.
    • distillery - A pure Elixir implementation of release packaging functionality for the Erlang VM.
    • eliver - Interactive semantic versioning for Elixir packages.
    • expublish - Automates semantic release versioning and best practices for elixir packages.
    • exrm - Automatically generate a release for your Elixir project.
    • exrm_deb - Create a deb for your Elixir release with ease.
    • exrm_heroku - Publish your Elixir releases to Heroku with ease.
    • exrm_rpm - Create a RPM for your Elixir release with ease.
    • mix_docker - Put your Elixir app production release inside minimal docker image.
    • relex - Erlang/Elixir Release Assembler.
    • renew - Mix task to create mix projects that builds into Docker containers.
    • versioce - An extensible version bumping and changelog generation for your mix project.

  • Templating

    • bbmustache - Binary pattern match Based Mustache template engine for Erlang/OTP.
    • calliope - An Elixir HAML parser.
    • eml - Library for writing and manipulating (HTML) markup in Elixir.
    • exgen - A templating library for quickly generating Elixir projects.
    • expug - Pug templates for Elixir.
    • mustache - Mustache templates for Elixir.
    • mustachex - Mustache for Elixir - Logic-less templates.
    • slime - An Elixir library for rendering slim-like templates.
    • sneeze - Render elixir data structures to HTML. Inspired by [hiccup](https://github.com/weavejester/hiccup).
    • taggart - HTML as code in Elixir.
    • templates - Helper library for adding templating to web applications.
    • temple - An HTML DSL for Elixir and Phoenix.

  • Video

    • ffmpex - FFmpeg command line wrapper.
    • silent_video - Convert GIFs and videos to silent videos, optimized for mobile playback.

  • YAML

    • fast_yaml - Fast YAML is an Erlang wrapper for libyaml "C" library.
    • yamerl - YAML 1.2 parser in Erlang.
    • yaml_elixir - Yaml parser for Elixir based on native Erlang implementation.
    • ymlr - A YAML encoder for Elixir.
    • yomel - libyaml interface for Elixir.

  • Data Visualization

    • plox - Server-side rendered SVG graphing components for Phoenix and LiveView.
Programming Languages
Elixir 1,140 Erlang 109 C 13 JavaScript 5 CSS 5 HTML 5 Gleam 2 Python 2 Shell 2 C++ 2
Categories
Third Party APIs 140 ORM and Datamapping 109 Text and Numbers 89 Algorithms and Data structures 88 Framework Components 85 Testing 69 Miscellaneous 68 Authentication 49 HTTP 42 Books 39 Queue 35 Applications 31 Build Tools 29 Examples and funny stuff 28 Utilities 28 Macros 27 Logging 24 Date and Time 23 Cloud Infrastructure and Management 21 Images 21 Networking 20 Instrumenting / Monitoring 19 Files and Directories 19 JSON 19 Geolocation 18 Websites 16 Cryptography 16 Command Line Applications 15 Debugging 15 Validations 15 Screencasts 15 Configuration 15 Artificial Intelligence 15 Frameworks 15 XML 14 Email 14 Protocols 13 Caching 12 Release Management 12 Chatting 12 Templating 12 Deployment 12 Security 11 Code Analysis 11 REST and API 11 Static Page Generation 10 Documentation 10 Translations and Internationalizations 9 Community 9 Reading 9 HTML 8 Podcasts 8 Games 8 CSV 7 Statistics 6 PDF 6 Authorization 6 Newsletters 6 Errors and Exception Handling 6 Eventhandling 6 Editors 6 Actors 6 Behaviours and Interfaces 6 Search 5 Native Implemented Functions 5 Domain-specific language 5 Natural Language Processing (NLP) 5 Markdown 5 Audio and Sounds 5 YAML 5 OTP 4 Feature Flags and Toggles 4 Office 4 Other Awesome Lists 4 Benchmarking 4 Bittorrent 4 Feeds 4 Package Management 3 Lexical analysis 3 BSON 3 ECMAScript 3 Languages 3 WebAssembly 3 Formulars 2 Hardware 2 Encoding and Compression 2 Video 2 GUI 2 Embedded Systems 2 Version Control 2 SMS 1 QUIC 1 Cheat Sheets 1 Data Visualization 1
Sub Categories
Keywords
elixir 438 elixir-lang 73 phoenix 64 erlang 59 hex 44 ecto 33 elixir-library 28 phoenix-framework 25 plug 21 authentication 15 database 15 elixir-phoenix 13 testing 12 json 12 http 12 ueberauth 10 oauth 10 oauth2 10 otp 10 api 9 metrics 9 slack 8 package 8 data-structures 8 html 8 redis 8 distributed-systems 7 security 7 monitoring 7 macros 7 beam 7 xml 7 graphql 7 instrumentation 7 mix-tasks 6 mix 6 kubernetes 6 exunit 6 liveview 6 ueberauth-strategies 6 prometheus 6 framework 6 machine-learning 6 stream 5 tutorial 5 websocket 5 configuration 5 parsing 5 encoding 5 deployment 5