Elixir Ecosystem Directory

Need a full-featured web framework?

Productive, reliable, and fast web framework with built-in WebSockets, PubSub, and real-time capabilities

Need HTTP request/response handling?

Composable HTTP middleware specification and adapter for web servers in Elixir

Need a lightweight HTTP server?

Pure Elixir HTTP server built for speed and correctness, supporting HTTP/1, HTTP/2, and WebSockets

Need a battle-tested HTTP server?

Small, fast, and modern Erlang HTTP server supporting HTTP/1.1, HTTP/2, and WebSocket

Need a full application framework with less boilerplate?

Declarative, resource-oriented application framework with built-in authorization, filtering, and API generation

Need interactive UIs without a JS framework?

Rich, real-time user experiences with server-rendered HTML — no JavaScript required

Need WebSocket support?

Real-time communication layer supporting WebSockets and long-polling with topic-based pub/sub

Need real-time event broadcasting?

Distributed pub/sub system for Phoenix with pluggable adapters for clustering

Need to track online users?

Track which users are online across distributed nodes with automatic conflict resolution via CRDTs

Need filterable lists in LiveView?

Composable, URL-driven filtering for LiveView with Linear/Notion-style UI and PostgREST-compatible params

Need a database layer and query builder?

Database toolkit with composable queries, migrations, schema validation, and multi-adapter support

Need a PostgreSQL driver?

Pure Elixir PostgreSQL driver with support for LISTEN/NOTIFY, streaming, and all Postgres types

Need a lightweight embedded database?

SQLite3 adapter for Ecto — perfect for embedded devices and single-node applications

Need pagination and filtering for lists?

Filtering, ordering, and pagination for Ecto queries with Phoenix LiveView integration

Need an audit trail for data changes?

Track and record all changes to your Ecto models with version history

Need change data capture from Postgres?

Listen to Postgres write-ahead log changes via logical replication for real-time database events

Need to distribute database schemas with your library?

Versioned PostgreSQL migrations for Elixir libraries with raw SQL, functions, triggers, and RLS policies

Need workflow orchestration backed by Postgres?

Postgres-powered workflows, background jobs, and cron with DAG execution, retries, and PGMQ

Need reliable background job processing?

Robust, Postgres-backed job processing with scheduling, priorities, unique jobs, rate limiting, and web UI

Need scheduled recurring tasks?

Cron-like job scheduler with runtime configurability and timezone support

Need a stateful background process?

Generic server process for managing state, handling calls, and building concurrent systems

Need simple async work?

Convenient abstractions for running one-off async operations with supervision

Need concurrent data ingestion pipelines?

Build multi-stage, concurrent data processing pipelines with back-pressure and batch processing

Need back-pressure aware data processing?

Producer-consumer pipeline framework with built-in back-pressure for demand-driven data processing

Need to process data in parallel?

Computational parallel flows built on GenStage for bounded and unbounded data processing

Need audio/video processing?

Multimedia processing framework for audio, video, and streaming with pipeline architecture

Need a modern HTTP client?

Batteries-included HTTP client with retries, compression, caching, and streaming built in

Need a high-performance HTTP client?

HTTP client with connection pooling built on Mint and NimblePool for high-performance requests

Need a flexible, middleware-based HTTP client?

Composable HTTP client with middleware architecture and swappable adapters

Need fine-grained HTTP connection control?

Low-level, functional HTTP client providing process-less connections for HTTP/1 and HTTP/2

Need user authentication?

Built-in Phoenix authentication generator with secure defaults, sessions, and confirmation

Need JWT/token authentication?

Token-based authentication with JWT support, pluggable serializers, and refresh tokens

Need social login / OAuth?

Composable OAuth authentication with strategies for Google, GitHub, Facebook, and more

Need full-featured user management?

Robust, modular user authentication and management with email confirmation and password reset

Need secure password hashing?

Bcrypt password hashing for Elixir with NIF bindings for performance

Need role-based authorization?

Simple, policy-based authorization that integrates with Phoenix controllers and LiveView

Need OAuth integrations with third-party services?

Drop-in OAuth integration for Phoenix with encrypted tokens, PKCE, and 500+ pre-configured providers

Need a test framework?

Built-in test framework with async test support, doctests, setup callbacks, and rich assertions

Need test data factories?

Test factory library for creating Ecto structs and maps with associations

Need mocking for tests?

Library for defining concurrent, explicit mocks based on behaviours

Need mocking without behaviours?

Flexible mocking library combining the best of Mox and Meck with stubs, expectations, and call tracking

Need to mock external API calls?

Stub external HTTP requests by creating a custom plug server on a local port

Need end-to-end browser testing?

Browser-based integration testing with concurrent sessions and automatic screenshots

Need to test with random inputs?

Property-based testing and data generation for finding edge cases automatically

Need numerical computing and tensors?

Multi-dimensional tensors and numerical computing with GPU/TPU acceleration via backends

Need to run ML models?

Run pre-trained HuggingFace models natively in Elixir — text generation, image classification, embeddings, and more

Need classical ML algorithms?

Traditional machine learning algorithms — clustering, regression, classification, dimensionality reduction

Need to build neural networks?

Neural network library with model building, training, and optimization on top of Nx

Need data manipulation and analysis?

DataFrames and series for Elixir with lazy and eager evaluation, powered by Polars

Need interactive data exploration?

Interactive notebook for Elixir with real-time collaboration, smart cells, and visualization

Need application metrics?

Dynamic event dispatching library for metrics and instrumentation across the ecosystem

Need application logging?

Built-in structured logging with configurable backends, levels, and metadata

Need application monitoring?

Real-time web dashboard for Phoenix apps — metrics, request logging, OS monitoring, and ETS inspection

Need distributed tracing?

Distributed tracing and metrics collection compatible with the OpenTelemetry standard

Need to debug production issues?

Erlang diagnostic tools for production — process info, memory analysis, and tracing

Need to inspect running processes?

Built-in GUI tool for inspecting running BEAM processes, memory, and system information

Need an in-memory cache?

Feature-rich in-memory cache with TTL, size limits, warming, stats, and distributed support

Need distributed caching across nodes?

Distributed caching framework with pluggable adapters — local, partitioned, replicated, and multilevel

Need fast in-process data storage?

Built-in in-memory key-value store with constant-time lookups and concurrent read access

Need ETS caching with TTL?

Simple, concurrent caching on top of ETS with TTL, key isolation, and callback support

Need to send emails?

Composable email library with adapters for Mailgun, SendGrid, SES, SMTP, and more

Need email with testability?

Flexible, composable email library with testing support and adapter architecture

Need to inline CSS for email?

Inline CSS styles in HTML emails for maximum email client compatibility

Need to run your own SMTP server?

Erlang SMTP client and server library for building email infrastructure

Need a GraphQL API?

Full-featured GraphQL implementation with subscriptions, batching, and dataloader integration

Need API documentation and validation?

Generate and validate OpenAPI 3.0 specs from your Phoenix controllers automatically

Need gRPC services?

Pure Elixir gRPC implementation for high-performance service-to-service communication

Need JSON:API compliant endpoints?

JSON:API 1.0 specification compliant serializer and deserializer for Phoenix

Need a PostgREST-compatible API in your app?

PostgREST/Supabase-compatible REST API layer for Elixir built on Plug and Ecto

Need JSON encoding/decoding?

Blazing fast JSON parser and generator for Elixir, used as the default across the ecosystem

Need a build tool and task runner?

Built-in build tool for creating, compiling, testing, and managing Elixir projects

Need package management?

Package manager for the Erlang ecosystem with dependency resolution and publishing

Need an interactive REPL?

Built-in interactive shell with code completion, debugging, and remote node connection

Need project documentation?

Documentation generator that produces beautiful HTML and EPUB from module docs and typespecs

Need a linter for Elixir?

Static code analysis with a focus on code consistency and teaching good practices

Need type checking?

Mix tasks for Dialyzer — static type analysis to catch bugs before runtime

Need to convert HTML to Markdown?

Convert HTML to clean Markdown with smart content extraction that filters out navigation and ads

Need code formatting?

Built-in opinionated code formatter that enforces consistent style across your project

Need to build IoT/embedded devices?

Build and deploy bulletproof embedded software in Elixir for Raspberry Pi, BeagleBone, and custom hardware

Need to manage device firmware updates?

Secure, over-the-air firmware update management for Nerves-powered IoT fleets

Need native UI for devices?

Functional UI framework for embedded devices and desktop applications with OpenGL rendering

Need network management on embedded devices?

Network configuration and management for Nerves devices — WiFi, Ethernet, LTE, and more