Erlang Concurrency

Create concurrent Erlang systems with processes and asynchronous message passing on BEAM.

187|20|Updated Nov 20, 2025

Search Tags:#concurrency #erlang #beam #fault-tolerance #processes

Ready to run

npx skills add https://github.com/TheBushidoCollective/han --skill erlang-concurrency

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: Erlang Concurrency
Source: https://github.com/TheBushidoCollective/han/tree/main/jutsu/jutsu-erlang/skills/erlang-concurrency
Command: npx skills add https://github.com/TheBushidoCollective/han --skill erlang-concurrency

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill teaches Erlang's concurrency model with processes, message passing, and fault tolerance on BEAM.

Core Features & Use Cases

Process Model: Lightweight processes and isolation.
Message Passing: Asynchronous communication patterns.
Fault Handling: Links, monitors, and supervision.

Quick Start

Spawn a simple process, send a message, and receive a reply.

Frequently Asked Questions about Erlang Concurrency

High-intent search queries and answers about installing and using this skill.

FAQPage Schema

How do I build concurrent systems with lightweight processes on BEAM?▼

Erlang's lightweight processes on BEAM let you spawn thousands of isolated actors that communicate asynchronously via message passing. Each process is independent, enabling massively scalable concurrent systems without shared memory or traditional threading overhead.

What's the difference between linking and monitoring processes in Erlang?▼

Links create bidirectional fault propagation—when a linked process crashes, the other exits by default. Monitors are unidirectional observers that send notifications without terminating the monitoring process, giving you fine-grained error handling without cascade failures.

How do I handle message passing patterns like publish-subscribe in Erlang?▼

Erlang's selective receive lets processes pattern-match incoming messages and handle them asynchronously. Publish-subscribe patterns route messages from producers to multiple consumer processes, enabling decoupled event-driven architectures and flexible messaging topologies.

Can I use Erlang processes for fault-tolerant distributed systems?▼

Yes. Erlang's supervision trees, links, and monitors provide fault tolerance by isolating failures to individual processes and restarting them automatically. This model scales from single-node BEAM applications to distributed systems with automatic recovery.

What are common concurrency patterns I can implement with Erlang processes?▼

Erlang supports parallel maps, fork-join workflows, pipelines, and publish-subscribe patterns. These patterns leverage process spawning, selective receive, and message routing to coordinate work across isolated processes efficiently.

Do I need prior knowledge of the actor model to use Erlang concurrency?▼

No. Erlang's process model teaches you the actor pattern through hands-on spawning, message passing, and fault handling. Basic familiarity with functional programming helps, but the Skill covers process creation and asynchronous communication from the ground up.