Lib.rs

ractor

A actor framework for Rust

gix-actor

A way to identify git actors

kameo

Fault-tolerant Async Actors Built on Tokio

spawned-concurrency

Spawned Concurrency

ractor_actors

actors built with Ractor

obzenflow-fsm

Async-first Finite State Machine library inspired by Akka (Classic) FSM

hannibal

A small actor library

hydra

A framework for writing fault tolerant, highly scalable applications with the Rust programming language

actix-telepathy

Cluster extension for the actix actor framework

maiko

Lightweight event-driven actor runtime with topic-based pub/sub for Tokio

tonari-actor

A minimalist actor framework aiming for high performance and simplicity

ector

open source async, no-alloc actor framework for embedded devices

act_rs

Act.rs is a minimal actor framework

acton-ern

handling Acton Entity Resource Names (ERNs), providing tools for generating, parsing, and managing ERNs within Acton Reactive-based solutions

rustack-sqs-core

SQS business logic and queue engine for Rustack

ghost_actor

GhostActor makes it simple, ergonomic, and idiomatic to implement async / concurrent code using an Actor model

stakker

A lightweight low-level single-threaded actor runtime

rtactor

An Actor framework specially designed for Real-Time constrained use cases

plexor-core

Core library for the rust implementation of the Plexo distributed system architecture, providing the fundamental Plexus, Neuron, Codec, and Axon abstractions

pasta_lua

Pasta Lua - Lua integration for Pasta DSL

tokio-actors

Zero-ceremony, Tokio-native actors with strong typing and production-ready edge case handling

cao-lang

The back-end of cao-lang, a node based visual scripting language

evno

A high-performance event bus for asynchronous tasks and event-driven systems

await-tree

Generate accurate and informative tree dumps of asynchronous tasks

actr-cli

Command line tool for Actor-RTC framework projects

xan-actor

Akka actor

dstate

Distributed state replication across actor-based clusters

kameo_actors

actors for kameo

async-curl

An asynchronous implementation to perform curl operations with tokio

murmer

A distributed actor framework for Rust

ringkernel-metal

Metal backend for RingKernel - Apple GPU support

acktor

Pure-Rust actor framework built on top of the Tokio async runtime

actr-version

Protocol compatibility analysis library using semantic proto analysis

apocalypse

actor framework for Rust

acto

light-weight Actor library for Rust

acton-ai

An agentic AI framework where each agent is an actor

uactor

The fastest and most modular actor system that doesn't force you to pay for what you don't need

actor-helper

Helper library for building actor systems

cruster

framework for building distributed, stateful entity systems with durable workflows

joerl

An Erlang-inspired actor model library for Rust

fluxion

actor framework written in rust and designed for distributed systems

acty

A lightweight, async actor framework built on Tokio

archy

An async application framework with services, systems, and dependency injection

moduforge-persistence

moduforge 持久化

moduforge-rules-expression

moduforge 表达式规则

elfo

An asynchronous distributed actor framework with robust observability

starlang

Erlang-style concurrency for Rust

ractor-supervisor

Supervisor module for ractor framework

moduforge-rules-template

moduforge 模板规则

wasm-actor-bridge

Typed, zero-copy Web Worker bridge for Rust/WASM actor systems

actr-framework-protoc-codegen

Protoc plugin for generating actr-framework code from protobuf definitions

ractor_cluster

Distributed cluster environment of Ractor actors

ringkernel-cpu

CPU backend for RingKernel - testing and fallback implementation

ringkernel-wgpu

WebGPU backend for RingKernel - cross-platform GPU support

palladium-plugin-api

Zero-dependency C ABI types for Palladium plugin boundaries

starlang-atom

Atom (interned string) implementation for Starlang

theta

Actor Framework

moduforge-collaboration-client

moduforge 协作系统

fraktor-rs

Specification-driven actor runtime bridging Akka/Pekko and Proto.Actor semantics across no_std and std targets

palladium-federation

Distributed cluster membership and federated actor registry for Palladium

tokactor

A actor model framework wrapped around tokio

gabriel2

Indeed, an actor library based on Tokio, written in Rust

vuo

An asynchronous stream processing library for Rust, built on Actix, providing a rich set of functional operators

actr-protocol

Unified protocol, types, and URI parsing for Actor-RTC framework

xtra

A tiny actor framework

elfo-logger

Logs events of the elfo system

bastion

Fault-tolerant Runtime for Rust applications

wasmcloud-interface-httpserver

interface for actors to receive http requests (wasmcloud:httpserver)

truba

The minimal tokio runtime based actors for Rust

actr

Actor-RTC: A WebRTC-native actor framework for distributed real-time systems

myriam

Actor model implementation for local and remote actors

edp_node

High-level Erlang Distribution Protocol node implementation

cell-core

Core primitives for the Cell distributed computing framework

palladium-transport

TCP, QUIC, and in-process transports for Palladium actors

cineyma

A lightweight actor framework for Rust with typed messages, OTP-style supervision, and distributed clustering

agentor

Agent-native Actor runtime — an Actor-model execution platform designed for AI Agents

whisk

fast lockless async channels

pupactor

actor model library built with tokio

fraktor-utils-core-rs

Portable no_std toolbox primitives for the fraktor actor runtime

palladium-runtime

High-performance multi-core actor runtime for Palladium

actionqueue-actor

Remote actor registration, heartbeat monitoring, and capability routing for the ActionQueue task queue engine

prax-actix

Actix-web framework integration for Prax ORM

elfo-network

Distributed actors for elfo

devsper-graph

Distributed AI Swarm Runtime

mdstream-tokio

Tokio glue for mdstream (delta coalescing and optional actor helpers)

tiny-tokio-actor

tiny actor library on top of tokio

wasmcloud-interface-numbergen

interface for actors to generate random numbers and guids (wasmcloud:builtin:numbergen)

may_actor

Actor library based on MAY

wasmcloud-interface-httpclient

interface for actors to issue http/https requests (wasmcloud:httpclient)

kerberos_constants

Constants used by differente objects and actors of the Kerberos protocol

acton_test

Testing utilities for Acton actors, providing tools to help in the testing and validation of actor behavior

gmt_dos-clients_transceiver

GMT DOS Transmitter/Receiver Clients

acmap

An actor-style sharded async map inspired by DashMap-like APIs

ascolt

Async runtime-agnostic actor framework

tcpclient

Asynchronous tcpclient based on aqueue actor

palladium-http

HTTP listener integration for the Palladium actor runtime

mofa-runtime

MoFA Runtime - Message bus, agent registry, and event loop

multi-stash

Vector-based arena data structure that reuses vacant slots

rukko

communicating with JVM-based Pekko actors

theater

A WebAssembly actor system for AI agents

starlang-runtime

Runtime infrastructure for Starlang - process registry, scheduler, mailboxes

palladium-cli

Command-line interface and control plane client for Palladium

heph-inbox

Bounded capacity channel designed to be used as inbox for actors. Also supports one shot channels.

crb-agent

CRB | Composable Runtime Blocks | Agent

rustkernel-ecosystem

Web framework integrations for RustKernels: Axum REST, Tower middleware, gRPC, Actix actors

mailboxxy

micro actor library for rust

codas-flow

Low-latency, high-throughput bounded queues ("data flows") for (a)synchronous and event-driven systems

starlang-gen-server

GenServer pattern for Starlang

palladium-plugin

Native (cdylib) and WASM plugin system for Palladium actors

elfo-test

Test utils for the elfo system

vin

An ergonomic actor framework

elfo-configurer

Loads and distributes configs across the elfo system

messages

Runtime-agnostic actor library

tokio-cast

CAST algorithm implementation for code RAG pipelines, powered by tokio-actors

elfo-utils

Some utils for the elfo system

fraktor-utils-std-rs

Standard-library helpers complementing fraktor-utils-core

xactor

actors framework based on async-std

spaad

Zero boilerplate actor systems with xtra

strontium-palladium

Deterministic fault-bridge contracts for Palladium actor simulations under Strontium control

act_rs_tokio

Act.rs Tokio is a minimal Tokio oriented actor framework

starlang-supervisor

Supervisor pattern for Starlang

dstate-kameo

Kameo adapter for the dstate distributed state crate

dstate-ractor

Ractor adapter for the dstate distributed state crate

starlang-process

Process primitives for Starlang - spawn, link, monitor, send/receive

common-game

A package for the 2025 Group Project of the course of Advanced Programming at the University of Trento

elfo-dumper

Dumps messages of the elfo system on disk

simpl_actor

tokio actors

superqueue

A tiny, lock-light, type-routed message bus providing event streams and latest-value topics (snapshots) for fast state and event dispatch

kappa

actor framework, this one based on the lambdas/behaviors

elfo-pinger

Pings groups of the elfo system

lifeline

dependency injection library for asynchronous message-based applications

can-isotp-queue

Queue/actor adapter for split ISO-TP TX/RX endpoints across async runtimes

elfo-telemeter

Collects and exposes metrics of the elfo system

crb-send

CRB | Composable Runtime Blocks | Send

actix-mqtt-client

A MQTT client based on the actix framework

priact

A lightweight and ergonomic Actor implementation for Rust, built on tokio, featuring explicit message prioritization via a BinaryHeap

webhttp

fraktor-actor-std-rs

fraktor std helpers for host runtimes

wasmcloud-interface-blobstore

Interface for accessing an object store over the wasmcloud:blobstore contract

thespis

The interface of the thespis actor model (contains only traits)

catloaf

core-affine, thread-local, opinionated actor framework

ductile

A channel implementation that allows both local in-memory channels and remote TCP-based channels with the same interface

lua_actor

Lua Actor for Rust(sync/async)

act_rs_smol

Act.rs smol is a minimal smol oriented actor framework

slacktor

extremely fast, bare-bones, low-overhead, supervisorless, no-std actor library

co-actor

Very lightweight actor abstraction over tokio channels

starlang-application

Application lifecycle management for Starlang

maxim

Implements a highly-scalable and ergonomic actor system for Rust based on the best of Erlang / Elixir and Akka. A fork of the Axiom actor framework.

zestors

A fast and flexible actor-framework for building fault-tolerant Rust applications

miniactor

Small, simple actor library for Rust

acto-rs

Experimental actor library, under development. (renamed from minions_rs).

actr-mailbox

Persistent mailbox layer for the Actor-RTC framework, backed by SQLite

overclock

A framework for building data-driven distributed systems

tyra

Typed Actor System

genserver

Elixir inspired async actor library

axiom

Implements a highly-scalable and ergonomic actor system for Rust based on the best of Erlang / Elixir and Akka

woab

Widgets on Actors Bridge - a GUI microframework for combining GTK with Actix

tiny-actor

A minimal actor framework for Rust

interlink

Framework for writing async code

tcp-channel-client

Asynchronous tcpclient based on aqueue actor

actr-runtime

Runtime layer for Actor-RTC framework - actor system, scheduler, and orchestration

actorizor

macro based actor framework for Tokio-based apps

fraktor-actor-core-rs

fraktor no_std actor runtime core

dsl-ractor

Reduce boilerplate when working with the Ractor actor framework

navactor

A cli tool for creating and updating actors from piped input

awol2005ex_kerberos_constants

Constants used by different objects and actors of the Kerberos protocol

lunatic-runtime

An actor platform built on WebAssembly

nsq-client

Rust client for the NSQ realtime message processing system

lwactors

Lightweight actors for Rust using futures-rs

movie

An actor / thread orchestration library / macro / framework

theater-server-cli

Standalone CLI for Theater server management

acu

building asynchronous actors

worker-pool

handle a set of worker threads, which need to communicate back their result to the main thread

cyberex_xasync

Cyberex Async

hollywood

actor framework

boomerang

Deterministic Middleware for Robotics

atticus

A mimimal API to create asynchronous actors

requiem

Actor framework for Rust

work_dispatcher

concurrent data processing framework

xtor

Async Actor framework for Rust which is blazing fast and rock solid

backstage

A framework for building data-driven distributed systems

wasmcloud

A secure, distributed, WebAssembly actor model runtime for the cloud, edge, and everything in between

crb-actor

CRB | Composable Runtime Blocks | Actor

ledb-actix

LEDB Actor for Actix actor framework and storage REST-interface

abcgen

A procedural macro to generate boilerplate code for objects implementing the 'Actor' pattern

mlua_actor

Lua Actor for Rust(sync/async)

fws_actors

fastwebsockets clients and servers in actors

lib3h_zombie_actor

lib3h actor request tracking module

aktors

Driver for derive-aktor

cooper

in-process, async Actor library for Rust

theatre

A concise async actor model implementation

wick-component

Macros and exports used to create Wick components

murray

A minimal actor definition macro using Tokio

relearn

A Reinforcement Learning library

mqtt_actor

An mqtt adapters (from port and adapters) to be used with actix actors

flo-state

Lightweight actor library

maikklein/unreal-ffi

Rust integration for Unreal Engine 5

himmelblau_kerberos_constants

Constants used by different objects and actors of the Kerberos protocol

maikklein/unreal-api

Rust integration for Unreal Engine 5

wascc-actor

SDK for developing WebAssembly Actor modules for hosting in waSCC

act-locally

single-threaded async actors with ordinary functions as handlers and plainly typed messages

riker-cqrs

Command Query Responsibility Separation for Riker applications

starlang-core

Core types for Starlang - Erlang-style concurrency for Rust

pipeworks

Robust data processing pipelines

actix-signal

Manage the lifecycle of an actix actor with its address

felicia

service for accessing and sharing lists of bad actors

wasmind_llm_types

Common LLM API types and structures for AI actors

tractor

Actor system modelled after Pony's actors

fort

Proc macro attributes for Bastion runtime

theater-cli

Command-line interface for Theater actor system

vino-provider

SDK for native and WASM Vino components

lakka

actors with macros

funfsm

An FSM library where the states are functions

wasmind_config

Configuration system for Wasmind actors and runtime

simple-actor

Helper to write actor-based async code

fibril

implementing distributed systems with commmunicating fibers

agner-sup

An actor toolkit inspired by Erlang/OTP (supervisors)

akt

An actors library for Rust and Tokio designed to work with async / await message handlers out of the box

quix

Distribution layer for actix

mailbox_processor

A small little actor abstraction inspired by the FSharp Mailbox Processor which in turn was inspired by erlang

ringkernel-core

Core traits and types for RingKernel GPU-native actor system

actix-ws-ng

WebSockets for Actix Web, without actors

wasmflow-packet

encapsulating the message packets sent across Wasmflow components

elfo-macros-impl

Macros for matching and deriving messages, implementation internals

simple-tokio-watchdog

Pretty simple but bulletproof watchdog actor

rosey-actors

Actor framework

nexus-actor-core-rs

Core library for Nexus Actor

keeshond_treats

Easy building blocks for Keeshond so you can start making your games sooner

elfo-core

The core of the elfo system

herolib-derive

Derive macros for herolib (ToSchema, ToHeroScript, FromHeroScript, Otoml, Actor, rpc_method, OpenRPC client)

stronghold-communication

libp2p-noise based communication system for IOTA Stronghold

agner-utils

An actor toolkit inspired by Erlang/OTP (utils)

heph-rt

speciailised runtime for Heph's actor

atomic-actor

An Actor with async fn handlers

kameo_macros

Fault-tolerant Async Actors Built on Tokio macros

wasmind_actor_utils

helpers for building Wasmind actors in Rust