Simple from zero to scale

Fast development with robust practices
Grows from teams of one to hundreds
Scales from single servers to global networks
Built on decades of Erlang reliability and fault-tolerance

Code as data transformations


                  "hello world"
|> String.split()
|> Enum.map(&String.capitalize/1)
|> Enum.join(" ")
#=> "Hello World"


                  user = %{name: "Alice", age: 30}
%{name: name, age: age} = user
[first | rest] = [1, 2, 3]
{:ok, _} = Map.fetch(user, :age)
#=> name = "Alice"


                  pid = spawn(fn -> work() end)
send(pid, {:msg, "hi"})
receive do
  msg -> IO.puts(msg)
end


                  {:ok, pid} = GenServer.start_link(
  Counter, 0
)
GenServer.cast(pid, :increment)
#=> :ok

Why Elixir?

Maintenance

Elixir helps developers write clear and purposeful code that focuses on your data and your domain. Thanks to immutability and memory safety, you can build systems that recover from failures and are easy to maintain.

Scalability

A single Elixir codebase can scale vertically (on multi-core machines) and horizontally (communicating across nodes), excelling at message-oriented and web real-time systems. Combined with projects like [Numerical Elixir], Elixir scales across cores, clusters, and GPUs.

Loved by developers

Voted one of the world's most admired languages several years in a row.

Go to survey

Productivity

Elixir ships with a package manager, code formatter, and best in class documentation. Projects like IEx (interactive shell) and Livebook (interactive notebooks) enable rapid prototyping and live-debugging of running systems.

Elixir in production

Elixir is used by solopreneurs and Fortune 500 companies alike, supporting teams that value developer happiness as well as large-scale operations, across diverse industries and applications.

See our cases

Use Elixir for

“Phoenix allows us to build the future with confidence — systems that grow, adapt, and never slow down.”

John Doe, CEO of Phoenix

Phoenix
LiveView
Ecto
Plug

“Nerves allows us to build the future with confidence — systems that grow, adapt, and never slow down.”

John Doe, CEO of Company

Nerves
IoT

“Nx allows us to build the future with confidence — systems that grow, adapt, and never slow down.”

John Doe, CEO of Company

Nx
LiveBook
Bumblebee
Axon

“Broadway allows us to build the future with confidence — systems that grow, adapt, and never slow down.”

John Doe, CEO of Company

Broadway
Membrane

“Broadway allows us to build the future with confidence — systems that grow, adapt, and never slow down.”

John Doe, CEO of Company

Broadway
Membrane

What will you build?

The ecosystem grows every day. Explore thousands of community packages on Hex and find the tools for your next project.

Install now See all packages

current_process = self()

# Spawn an Elixir process (not an operating system one!)
spawn_link(fn ->
  send(current_process, {:msg, "hello world"})
end)

# Block until the message is received
receive do
  {:msg, contents} -> IO.puts(contents)
end

# Open GPIO pin 17 for output
{:ok, gpio} = Circuits.GPIO.open(17, :output)

# Pulse an LED on the board
Circuits.GPIO.write(gpio, 1)
Process.sleep(500)
Circuits.GPIO.write(gpio, 0)

# Release the pin on shutdown
Circuits.GPIO.close(gpio)

# Load a pretrained model from Hugging Face
{:ok, model} = Bumblebee.load_model({:hf, "bert-base"})
{:ok, tokenizer} = Bumblebee.load_tokenizer({:hf, "bert-base"})

# Run fill-mask inference on a prompt
Bumblebee.Text.fill_mask(model, tokenizer,
  "The cat sat on the [MASK].")

defmodule MyPipeline do
  use Broadway

  # Process each message in parallel
  def handle_message(_processor, message, _ctx) do
    message
    |> Message.update_data(&transform/1)
  end
end

# Read a sensor value over I²C
{:ok, ref} = Circuits.I2C.open("i2c-1")
<<temp::16>> = Circuits.I2C.read!(ref, 0x48, 2)

# Publish the reading to NervesHub
NervesHub.publish("sensors/temp", %{value: temp})

current_process = self()

# Spawn an Elixir process (not an operating system one!)
spawn_link(fn ->
  send(current_process, {:msg, "hello world"})
end)

# Block until the message is received
receive do
  {:msg, contents} -> IO.puts(contents)
end

# Open GPIO pin 17 for output
{:ok, gpio} = Circuits.GPIO.open(17, :output)

# Pulse an LED on the board
Circuits.GPIO.write(gpio, 1)
Process.sleep(500)
Circuits.GPIO.write(gpio, 0)

# Release the pin on shutdown
Circuits.GPIO.close(gpio)

# Load a pretrained model from Hugging Face
{:ok, model} = Bumblebee.load_model({:hf, "bert-base"})
{:ok, tokenizer} = Bumblebee.load_tokenizer({:hf, "bert-base"})

# Run fill-mask inference on a prompt
Bumblebee.Text.fill_mask(model, tokenizer,
  "The cat sat on the [MASK].")

defmodule MyPipeline do
  use Broadway

  # Process each message in parallel
  def handle_message(_processor, message, _ctx) do
    message
    |> Message.update_data(&transform/1)
  end
end

# Read a sensor value over I²C
{:ok, ref} = Circuits.I2C.open("i2c-1")
<<temp::16>> = Circuits.I2C.read!(ref, 0x48, 2)

# Publish the reading to NervesHub
NervesHub.publish("sensors/temp", %{value: temp})

current_process = self()

# Spawn an Elixir process (not an operating system one!)
spawn_link(fn ->
  send(current_process, {:msg, "hello world"})
end)

# Block until the message is received
receive do
  {:msg, contents} -> IO.puts(contents)
end

# Open GPIO pin 17 for output
{:ok, gpio} = Circuits.GPIO.open(17, :output)

# Pulse an LED on the board
Circuits.GPIO.write(gpio, 1)
Process.sleep(500)
Circuits.GPIO.write(gpio, 0)

# Release the pin on shutdown
Circuits.GPIO.close(gpio)

# Load a pretrained model from Hugging Face
{:ok, model} = Bumblebee.load_model({:hf, "bert-base"})
{:ok, tokenizer} = Bumblebee.load_tokenizer({:hf, "bert-base"})

# Run fill-mask inference on a prompt
Bumblebee.Text.fill_mask(model, tokenizer,
  "The cat sat on the [MASK].")

defmodule MyPipeline do
  use Broadway

  # Process each message in parallel
  def handle_message(_processor, message, _ctx) do
    message
    |> Message.update_data(&transform/1)
  end
end

# Read a sensor value over I²C
{:ok, ref} = Circuits.I2C.open("i2c-1")
<<temp::16>> = Circuits.I2C.read!(ref, 0x48, 2)

# Publish the reading to NervesHub
NervesHub.publish("sensors/temp", %{value: temp})

current_process = self()

# Spawn an Elixir process (not an operating system one!)
spawn_link(fn ->
  send(current_process, {:msg, "hello world"})
end)

# Block until the message is received
receive do
  {:msg, contents} -> IO.puts(contents)
end

# Open GPIO pin 17 for output
{:ok, gpio} = Circuits.GPIO.open(17, :output)

# Pulse an LED on the board
Circuits.GPIO.write(gpio, 1)
Process.sleep(500)
Circuits.GPIO.write(gpio, 0)

# Release the pin on shutdown
Circuits.GPIO.close(gpio)

# Load a pretrained model from Hugging Face
{:ok, model} = Bumblebee.load_model({:hf, "bert-base"})
{:ok, tokenizer} = Bumblebee.load_tokenizer({:hf, "bert-base"})

# Run fill-mask inference on a prompt
Bumblebee.Text.fill_mask(model, tokenizer,
  "The cat sat on the [MASK].")

defmodule MyPipeline do
  use Broadway

  # Process each message in parallel
  def handle_message(_processor, message, _ctx) do
    message
    |> Message.update_data(&transform/1)
  end
end

# Read a sensor value over I²C
{:ok, ref} = Circuits.I2C.open("i2c-1")
<<temp::16>> = Circuits.I2C.read!(ref, 0x48, 2)

# Publish the reading to NervesHub
NervesHub.publish("sensors/temp", %{value: temp})

current_process = self()

# Spawn an Elixir process (not an operating system one!)
spawn_link(fn ->
  send(current_process, {:msg, "hello world"})
end)

# Block until the message is received
receive do
  {:msg, contents} -> IO.puts(contents)
end

# Open GPIO pin 17 for output
{:ok, gpio} = Circuits.GPIO.open(17, :output)

# Pulse an LED on the board
Circuits.GPIO.write(gpio, 1)
Process.sleep(500)
Circuits.GPIO.write(gpio, 0)

# Release the pin on shutdown
Circuits.GPIO.close(gpio)

# Load a pretrained model from Hugging Face
{:ok, model} = Bumblebee.load_model({:hf, "bert-base"})
{:ok, tokenizer} = Bumblebee.load_tokenizer({:hf, "bert-base"})

# Run fill-mask inference on a prompt
Bumblebee.Text.fill_mask(model, tokenizer,
  "The cat sat on the [MASK].")

defmodule MyPipeline do
  use Broadway

  # Process each message in parallel
  def handle_message(_processor, message, _ctx) do
    message
    |> Message.update_data(&transform/1)
  end
end

# Read a sensor value over I²C
{:ok, ref} = Circuits.I2C.open("i2c-1")
<<temp::16>> = Circuits.I2C.read!(ref, 0x48, 2)

# Publish the reading to NervesHub
NervesHub.publish("sensors/temp", %{value: temp})

Shaped by many

Elixir is shaped by the contributions of many. The Elixir Team steers the language and the Erlang Ecosystem Foundation supports Elixir and the broader Erlang community.

Erlang Ecosystem Foundation

Join the foundation

Elixir Open Source Pioneers

A collective of companies that employ developers to work full-time on ecosystem tooling.

Learn more