Erlang OTP: Distributed & Fault-Tolerant Systems Programming · Lesson

Creating Erlang Releases

Use tools like rebar3 and relx to bundle your Erlang application, its dependencies, and the Erlang runtime into a self-contained release.

Creating Erlang Releases is a free Erlang OTP: Distributed & Fault-Tolerant Systems Programming lesson on CoddyKit — lesson 1 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Erlang OTP: Distributed & Fault-Tolerant Systems Programming learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

What are Erlang Releases?

When you develop an Erlang application, it's a collection of modules and configuration files. To deploy it, you need to package it all up.

An Erlang Release is a self-contained, deployable package of your application, its dependencies, and optionally, a specific version of the Erlang Runtime System (ERTS).

It's like a standalone executable for your Erlang system.
It simplifies deployment by bundling everything needed to run.

Benefits of a Release

Why go through the effort of creating a release? Releases offer significant advantages for production systems:

Self-contained: Includes all necessary Erlang libraries and even the Erlang VM itself.
Simplified Deployment: Just copy the release folder to a server and start it.
Version Management: Each release has a clear version number, making upgrades and rollbacks easier.
Foundation for Live Upgrades: Releases are essential for Erlang's famous 'hot code loading' feature (covered in a later lesson!).

Meet rebar3

Building Erlang applications and releases manually can be complex. Fortunately, we have rebar3!

rebar3 is the standard build tool for Erlang. It handles:

Project creation and management
Dependency resolution
Compilation
Testing
And, crucially for this lesson, creating releases.

It streamlines the entire development and deployment workflow.

Your Erlang Application Code

Let's start with a very simple Erlang module. In a real application, this would be part of your overall system logic.

For demonstration, we'll create a module with a main/0 function, which can be run directly. This module will be included in our release.

-module(my_release_app).
-export([main/0]).

main() ->
    io:format("Hello from my Erlang release application!~n").

The Application Resource File

Every Erlang application has an application resource file (.app or .app.src). This file defines metadata about your application, such as its version, description, and which modules it depends on.

rebar3 uses the .app.src file to generate the final .app file during the build process.

{application, my_release_app,
 [{description, "My simple release app"},
  {vsn, "0.1.0"},
  {registered, []},
  {applications, [
    kernel,
    stdlib
  ]},
  {mod, {my_release_app, []}},
  {env, []}
 ]}.

Configuring the Release

To tell rebar3 how to build your release, you add a relx section to your rebar.config file. This configuration specifies:

The name and version of your release.
Which applications to include.
If the Erlang Runtime System (ERTS) should be bundled.

For development, we often don't include ERTS to save space.

{apps, [my_release_app]}.

{relx, [{release, {my_release_app, "0.1.0"}, [my_release_app]},
        {dev_mode, true},
        {include_erts, false},
        {extended_start_script, true}]}.

Building Your Release Bundle

With your application code, .app.src, and rebar.config in place, building the release is straightforward. rebar3 will compile your code, fetch dependencies, and package everything into a single directory.

This command does all the heavy lifting:

rebar3 release

Inside the Release Package

After running rebar3 release, you'll find your release in _build/default/rel/my_release_app/. The structure typically includes:

bin/: Contains the start script for your application.
lib/: All your application's compiled code and dependencies.
releases/: Release definitions and version information.
erts/: (Optional) The Erlang Runtime System if include_erts was true.

This organized structure makes deployment predictable and reliable.

Running Your Packaged App

Once built, you can start your Erlang application by executing the generated start script. This script handles starting the Erlang VM and loading your application.

Navigate to the release directory and use the bin/<release_name> script.

For our example, you would run (in a shell, not runnable in this environment):

_build/default/rel/my_release_app/bin/my_release_app start

Release Benefits Check

Creating an Erlang release is a crucial step for deployment. Which of the following are primary benefits of packaging an Erlang application as a release?

Recap: Erlang Releases

You've taken a big step towards deploying Erlang applications!

Erlang Releases package your app, its dependencies, and optionally ERTS.
rebar3 is the essential tool for building and managing releases.
The .app.src and rebar.config files define your application and release.
Releases simplify deployment, versioning, and enable powerful features like live upgrades.

Next, we'll dive into the fascinating world of hot code loading and how to perform live upgrades on running systems!

Frequently asked questions

Is the “Creating Erlang Releases” lesson free?

Yes — the full text of “Creating Erlang Releases” is free to read here on the web, and the Erlang OTP: Distributed & Fault-Tolerant Systems Programming course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Erlang OTP: Distributed & Fault-Tolerant Systems Programming course, upgrade to CoddyKit PRO.

What will I learn in “Creating Erlang Releases”?

Use tools like rebar3 and relx to bundle your Erlang application, its dependencies, and the Erlang runtime into a self-contained release. You practise Erlang OTP: Distributed & Fault-Tolerant Systems Programming with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Erlang OTP: Distributed & Fault-Tolerant Systems Programming?

No prior experience is required. Erlang OTP: Distributed & Fault-Tolerant Systems Programming on CoddyKit is structured for beginners through advanced learners; this is — lesson 1 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Creating Erlang Releases” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Erlang OTP: Distributed & Fault-Tolerant Systems Programming lesson?

Yes. Every Erlang OTP: Distributed & Fault-Tolerant Systems Programming lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to Erlang OTP: Distributed & Fault-Tolerant Systems Programming