Getting started

Build concurrent Rust apps without locks, race conditions, or shared state nightmares.

Acton gives you independent workers that own their state privately and communicate through messages. If you can write async Rust, you can write actors—and your concurrent code will be correct by construction.

Choose your path

Actors eliminate data races by making isolation the default

Traditional concurrent Rust requires careful lock management:

// Shared state protected by locks...
let counter = Arc::new(Mutex::new(0));
let counter_clone = counter.clone();

// Spawn threads...
let handle = thread::spawn(move || {
    let mut num = counter_clone.lock().unwrap(); // Hope this doesn't deadlock!
    *num += 1;
});

// Hope you got all the Arc<Mutex<...>> right...

The problems: Lock contention, deadlocks, shared state bugs, and subtle race conditions that only appear in production.

Acton's solution: Each actor owns its data privately. No locks needed.

#[acton_actor]
struct Counter { count: i32 }

#[acton_message]
struct Increment;

builder.mutate_on::<Increment>(|actor, _msg| {
    actor.model.count += 1;
    Reply::ready()
});

handle.send(Increment).await;

What you get: No locks, isolated failures, guaranteed message ordering, and compile-time safety. Data races become impossible because actors never share mutable state.

A complete example in 20 lines

use acton_reactive::prelude::*;

#[acton_actor]
struct Counter { count: i32 }

#[acton_message]
struct Increment;

#[acton_main]
async fn main() {
    let mut app = ActonApp::launch();

    let handle = app
        .new_actor::<Counter>()
        .mutate_on::<Increment>(|actor, _| {
            actor.model.count += 1;
            println!("Count: {}", actor.model.count);
            Reply::ready()
        })
        .start()
        .await;

    handle.send(Increment).await.ok();
    handle.send(Increment).await.ok();
    handle.send(Increment).await.ok();

    app.shutdown_all().await.ok();
}

Output:

Count: 1
Count: 2
Count: 3

Each message is processed in order. The actor's state is never accessed concurrently. Ready to build? Start with Installation.

Two handler types cover every use case

// For mutations - one at a time, exclusive access
builder.mutate_on::<Increment>(|actor, _| {
    actor.model.count += 1;
    Reply::ready()
});

// For queries - can run concurrently with other reads
builder.act_on::<GetCount>(|actor, _| {
    Reply::with(actor.model.count)
});

See Messages & Handlers for the complete picture.

Current status

Start building now

• Installation — Add acton-reactive to your project
• Your First Actor — Hands-on tutorial with working code
• What are Actors? — Understand the actor model
• Cheatsheet — Copy-paste patterns for common tasks