Gleam’s type-safe actor model for Elixir and Erlang developers

The shift to static typing on the BEAM

I find Gleam’s static typing essential for reliable BEAM development. While Elixir uses dynamic typing, Gleam employs a Hindley-Milmer type system. Because Gleam uses a Hindley-Milmer type system, the compiler identifies structural mistakes in your code before you ever attempt to deploy your application to a production server on the BEAM. This prevents many runtime errors.

The compiler catches errors.

Gleam custom types act as tagged unions or records. You define a type and its constructors to represent different data structures. This approach allows for pattern matching with destructuring. You can define a type like Vehicle with constructors like Car and Skateboard. When you use a case structure, the compiler ensures you handle every possible constructor for the variable. This makes the code more predictable.

The language server handles types.

The Gleam CLI includes tools like gleam add to manage dependencies and gleam test to run project tests. You use gleam format to organize source code. This toolset reduces decision paralysis compared to Javascript. The Gleam compiler is written in Rust. This choice makes the compiler faster. The language server also provides type and documentation details when you hover over variables.

Building with the Gleam OTP library

Gleam’s gleam_otp library provides bindings for the actor model. It aims for full type safety of actors and messages. The library maintains compatibility with Erlang’s OTP framework. It provides fault tolerance and self-healing through supervisors. Developers find that the performance matches Erlang’s OTP. The package provides several different types of actor for Gleam programs.

The supervisor starts and manages other actors. If a child process crashes, the supervisor restarts it. This builds a supervision tree to provide fault tolerance. You already know the actor model, so I will skip the history. The actor remains the most used process type in the ecosystem, as it handles OTP system messages automatically.

The supervisor restarts it.

The library is experimental. It does not replicate all Erlang OTP functionality. There is no support for named processes. Actors do not support all OTP system messages. If you use an unsupported message, the system drops it. Supervisors do not prevent different shutdown periods for each child. This means children that are supervisors do not get an unlimited amount of time to shut down.

To use an actor, you need a custom type for messages, a function to handle those messages, and a function to start the process. You use actor.start to begin the process and actor.call to send a message and wait for a reply. This mechanism handles system messages automatically.

Interop and ecosystem reality

Gleam interops with Erlang and Elixir. You write @external annotations to define function signatures for Erlang code. This process adds more friction than Elixir. In Elixir, you call Erlang functions directly.

You cannot use Phoenix or LiveView directly. These frameworks rely on Elixir’s metaprogramming features. You must write Elixir glue code to interface with them.

The ecosystem is small. There is a shortage of documentation and libraries. I would skip the gleam_otp library if you require named processes or many actor abstractions.

The community is expanding. The framework draws inspiration from the Elm language. It runs on both the backend and the frontend.

The library works.

Can Gleam eventually replace Elixir for all web services?