Joerl

brings Erlang/OTP fault-tolerance semantics and actor abstractions to safe, async Rust.

The Pitch

Building fault-tolerant, concurrent systems requires clear message passing boundaries, supervision strategies, and isolated failure domains. While Erlang and Elixir excel at this, high-performance systems often demand Rust's zero-cost safety.

Joerl bridges this gap by implementing an Erlang-inspired actor framework in Rust. Define actors as isolated async tasks, supervise them with standard OTP strategies (one-for-one, one-for-all, rest-for-one), and pass strongly-typed messages without runtime overhead.

Why Joerl?

Erlang Semantics in Rust

Actors run as isolated Tokio tasks with message mailboxes and structured lifecycle management.

OTP Supervision Trees

Built-in supervisors supporting standard restart strategies ( one_for_one , one_for_all , rest_for_one ).

Type-Safe Messaging

Leverage Rust's enum and trait systems for compile-time verified message handling.

Zero-Cost Abstractions

Fast async execution with Tokio runtime without sacrificing safety or concurrency guarantees.

The Tech

Who It's For

• Systems Engineers building concurrent, fault-tolerant services in Rust.
• Erlang & Elixir Developers migrating high-throughput workloads to Rust while preserving actor design.
• Rust Engineers looking for structured supervision and process-like isolation.

Bottom Line

Bring Erlang/OTP process isolation and supervision trees to high-performance async Rust applications with Joerl.