Actor Framework in Rust

What You'll Build

We'll design and implement a complete actor framework in Rust from scratch — no external actor libraries, just async Rust primitives. Starting with the fundamental Actor trait, we'll progressively build a runtime, mailbox, context, address system, and event/interrupt/request-response patterns.

Along the way we'll explore key concurrency patterns: message passing via channels, trait-based polymorphism with async_trait, type-erased envelopes, lifecycle management with watch channels, and the Future trait for custom awaitable types. By the end, our framework supports fire-and-forget events, graceful interruption, and strongly-typed request-response interactions with a Calculator example to prove it all works.

Learning Objectives

Understand the actor model and its Rust implementation
Build an async runtime with Tokio-based message passing
Design type-erased message envelopes for heterogeneous mailboxes
Implement actor lifecycle management with status tracking
Create an event system with typed handlers
Build a graceful interruption mechanism
Refactor a single crate into a Cargo workspace
Implement a request-response pattern with oneshot channels
Build a custom Future type for awaitable responses

Prerequisites

Rust fundamentals (traits, generics, ownership)
Basic async Rust (async/await, Tokio)
Familiarity with channels and message passing

Course curriculum

1 Essential Types for Actors

Introduction and scaffolding
Defining the Actor trait

2 Runtime for Actors

Implementing an actor runtime
Defining message handling

3 Lifecycle of Actors

Detecting actor termination
Adding actor running status
Extracting messages
Processing events
Controlling an actor's lifetime
Sending messages to an actor
Interrupting actor execution

4 Events in Actors

Events handling extension
Testing events handling
Adding a fallback method
Adding a self-referenced address
Move dependencies to the workspace

5 Interaction with Actors

Adding the interaction trait
Integrating with actors
Sending a response
Implementing an address extension
Covering interaction with a test

6 Receiving responses

Retrieving values from a receiver
Handling responses asynchronously with OnResponse

Technologies

Rust Actor Model Async Trait Tokio Message Passing Concurrency Trait Object Type Erasure Oneshot Channel Future Cargo Workspace

Read the concepts behind this playground

FAQ

Is this a video course?

No. You implement the project yourself, step by step, right in your browser — with a full reference solution for every step when you get stuck.

Do I need to install anything?

No. The playground runs entirely in your browser — no toolchain or local setup required.

Can I try it before subscribing?

Yes. Preview steps are available without a subscription so you can see the format and quality first.

What do I get with full access?

Every step unlocked, the Workbench app, a snapshot for each step, jump-to-any-step navigation, and all new playground releases.

Does it work with an AI agent like Claude or Codex?

Yes. You can work through a playground solo or alongside an AI agent.

Is there reference code?

Yes. Every step has a complete reference solution you can compare against.