Build Concurrent Systems
that Don't Break
Cineyma is an actor framework for Rust with typed messages, supervision trees, and built-in clustering.
cargo add cineymaConcurrency without the headaches
The hard problems are already solved. You focus on your business logic.
No more runtime type errors
Messages are typed at compile time. The compiler catches mistakes before they reach production.
impl Handler<Increment> for Counter {
type Result = i32; // compiler enforced
}Bounded mailboxes
Built-in backpressure. Your actors won't eat all your memory under load.
Self-healing actors
OTP-style supervision restarts crashed actors automatically.
Scale beyond a single machine
Gossip protocol and failure detection built-in. Send messages to remote actors like they're local.
Simple by design
Define a message, implement a handler, spawn an actor. That's it.
use cineyma::{Actor, Handler, Message, ActorSystem, Context};struct Greet(String);impl Message for Greet { type Result = String;}struct Greeter;impl Actor for Greeter {}impl Handler<Greet> for Greeter { fn handle(&mut self, msg: Greet, _ctx: &mut Context<Self>) -> String { format!("Hello, !", msg.0) }}#[tokio::main]async fn main() { let system = ActorSystem::new(); let addr = system.spawn(Greeter); let response = addr.send(Greet("Cineyma".into())).await.unwrap(); println!("{}", response); // "Hello, Cineyma!"}From local to distributed
Start simple, scale horizontally when you need it.
Local Actors
Spawn actors, send messages, handle responses. All type-safe.
Remote Messaging
TCP transport with Protocol Buffers. Request-response over the network.
Cluster
Gossip protocol, failure detection, location-transparent messaging.
Ready to build?
One command to add Cineyma to your project. Start building resilient concurrent systems today.
$cargoadd cineyma