Actor Based Concurrency

Actors expose a message based API resulting in fast, non-blocking code execution while also eliminating race conditions to make concurrent code a breeze to write.

Self Healing

Build applications that isolate and recover from failures. Actors provide a Supervision Strategy that form the core of resilient application design in Riker.

Event Sourcing & CQRS

Use event sourcing and Command Query Responsibility Separation (CQRS) to drive extremely fast persistent data applications.

General Purpose

In the Cloud, Microservices, IoT, Drones, AI and more. Rust compiles to OS binaries, has no VM or GC overhead, and requires only a few megabytes of memory.

Modular Framework

Default thread management, concurrent logging, message scheduling and data persistence are included and can be switched for alternative implementations.

Modern Rust Design

Execute Rust Futures with ease and no unsafe code used.

Example Code

1struct MyActor;
2
3impl Actor for MyActor {
4    type Msg = String;
5
6    fn receive(&mut self,
7                ctx: &Context<Self::Msg>,
8                msg: Self::Msg,
9                sender: ActorRef<Self::Msg>) {
10
11        println!("received {}", msg);
12    }
13}
14
15let sys = ActorSystem::new(&model).unwrap();
16
17let props = MyActor::props();
18let a = sys.actor_of(props, "a").unwrap();
19
20a.tell("Hello actor!".to_string(), None);
21