Lib.rs

gix-actor

A way to identify git actors

ractor

A actor framework for Rust

kameo

Fault-tolerant Async Actors Built on Tokio

hannibal

A small actor library

ector

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

hydra

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

pasta_lua

Pasta Lua - Lua integration for Pasta DSL

nexus-actor-core-rs

Core library for Nexus Actor

tonari-actor

A minimalist actor framework aiming for high performance and simplicity

rtactor

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

act_rs

Act.rs is a minimal actor framework

await-tree

Generate accurate and informative tree dumps of asynchronous tasks

ractor_actors

actors built with Ractor

stakker

A lightweight low-level single-threaded actor runtime

maiko

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

evno

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

plexor-core

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

moduforge-rules-expression

moduforge 表达式规则

xan-actor

Akka actor

cao-lang

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

ghost_actor

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

async-curl

An asynchronous implementation to perform curl operations with tokio

kore-lang

A self-hosting programming language with Rust's safety, Python's syntax, and Lisp's metaprogramming

cineyma

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

actr-version

Protocol compatibility analysis library using semantic proto analysis

kameo_actors

actors for kameo

acton-ai

An agentic AI framework where each agent is an actor

starlang

Erlang-style concurrency for Rust

cruster

framework for building distributed, stateful entity systems with durable workflows

theta

Actor Framework

ringkernel-metal

Metal backend for RingKernel - Apple GPU support

acto

light-weight Actor library for Rust

ractor_cluster

Distributed cluster environment of Ractor actors

fluxion

actor framework written in rust and designed for distributed systems

acton-ern

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

obzenflow-fsm

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

ractor-supervisor

Supervisor module for ractor framework

nexus-actor-remote-rs

Remote library for Nexus Actor

apocalypse

actor framework for Rust

joerl

An Erlang-inspired actor model library for Rust

acty

A lightweight, async actor framework built on Tokio

moduforge-persistence

moduforge 持久化

archy

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

vuo

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

fraktor-rs

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

rukko

communicating with JVM-based Pekko actors

actr-framework-protoc-codegen

Protoc plugin for generating actr-framework code from protobuf definitions

myriam

Actor model implementation for local and remote actors

ringkernel-cpu

CPU backend for RingKernel - testing and fallback implementation

actix-telepathy

Cluster extension for the actix actor framework

common-game

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

ringkernel-wgpu

WebGPU backend for RingKernel - cross-platform GPU support

moduforge-collaboration-client

moduforge 协作系统

actr

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

moonpool

A place to experiment around actors

gabriel2

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

elfo

An asynchronous distributed actor framework with robust observability

truba

The minimal tokio runtime based actors for Rust

tokactor

A actor model framework wrapped around tokio

prax-actix

Actix-web framework integration for Prax ORM

superqueue

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

actr-protocol

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

actor-helper

Helper library for building actor systems

xtra

A tiny actor framework

mdstream-tokio

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

wasmcloud-interface-httpserver

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

elfo-telemeter

Collects and exposes metrics of the elfo system

may_actor

Actor library based on MAY

bastion

Fault-tolerant Runtime for Rust applications

tcpclient

Asynchronous tcpclient based on aqueue actor

uactor

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

edp_node

High-level Erlang Distribution Protocol node implementation

tiny-tokio-actor

tiny actor library on top of tokio

tokio-actors

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

actr-cli

Command line tool for Actor-RTC framework projects

gmt_dos-clients_transceiver

GMT DOS Transmitter/Receiver Clients

fraktor-utils-core-rs

Portable no_std toolbox primitives for the fraktor actor runtime

whisk

fast lockless async channels

pupactor

actor model library built with tokio

ascolt

Async runtime-agnostic actor framework

wasmcloud-interface-httpclient

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

wasmcloud-interface-numbergen

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

multi-stash

Vector-based arena data structure that reuses vacant slots

theater

A WebAssembly actor system for AI agents

kerberos_constants

Constants used by differente objects and actors of the Kerberos protocol

starlang-runtime

Runtime infrastructure for Starlang - process registry, scheduler, mailboxes

mailboxxy

micro actor library for rust

priact

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

acton_test

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

starlang-atom

Atom (interned string) implementation for Starlang

elfo-test

Test utils for the elfo system

starlang-gen-server

GenServer pattern for Starlang

awol2005ex_kerberos_constants

Constants used by different objects and actors of the Kerberos protocol

starlang-supervisor

Supervisor pattern for Starlang

starlang-application

Application lifecycle management for Starlang

act_rs_smol

Act.rs smol is a minimal smol oriented actor framework

heph-inbox

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

act_rs_tokio

Act.rs Tokio is a minimal Tokio oriented actor framework

simpl_actor

tokio actors

messages

Runtime-agnostic actor library

starlang-process

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

vin

An ergonomic actor framework

elfo-utils

Some utils for the elfo system

work_dispatcher

concurrent data processing framework

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

crb-agent

CRB | Composable Runtime Blocks | Agent

catloaf

core-affine, thread-local, opinionated actor framework

webhttp

fraktor-actor-std-rs

fraktor std helpers for host runtimes

actix-mqtt-client

A MQTT client based on the actix framework

kappa

actor framework, this one based on the lambdas/behaviors

codas-flow

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

wasmind_actor_loader

Dynamic actor loading and dependency resolution for Wasmind

elfo-network

Distributed actors for elfo

lifeline

dependency injection library for asynchronous message-based applications

elfo-dumper

Dumps messages of the elfo system on disk

crb-send

CRB | Composable Runtime Blocks | Send

miniactor

Small, simple actor library for Rust

wasmcloud-interface-blobstore

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

elfo-logger

Logs events of the elfo system

thespis

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

ductile

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

elfo-pinger

Pings groups of the elfo system

act-zero-ext

Macros for act-zero

wasmind_config

Configuration system for Wasmind actors and runtime

slacktor

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

lua_actor

Lua Actor for Rust(sync/async)

fraktor-actor-core-rs

fraktor no_std actor runtime core

wasmind_actor_utils_common_messages

Common message types shared between Wasmind actors

elfo-configurer

Loads and distributes configs across the elfo system

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

overclock

A framework for building data-driven distributed systems

acto-rs

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

actorizor

macro based actor framework for Tokio-based apps

tyra

Typed Actor System

theater-server-cli

Standalone CLI for Theater server management

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

pipeworks

Robust data processing pipelines

tiny-actor

A minimal actor framework for Rust

actr-runtime

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

wasmind_actor_utils

helpers for building Wasmind actors in Rust

cyberex_xasync

Cyberex Async

interlink

Framework for writing async code

dsl-ractor

Reduce boilerplate when working with the Ractor actor framework

tcp-channel-client

Asynchronous tcpclient based on aqueue actor

fws_actors

fastwebsockets clients and servers in actors

wasmind_llm_types

Common LLM API types and structures for AI actors

navactor

A cli tool for creating and updating actors from piped input

lwactors

Lightweight actors for Rust using futures-rs

lunatic-runtime

An actor platform built on WebAssembly

nsq-client

Rust client for the NSQ realtime message processing system

movie

An actor / thread orchestration library / macro / framework

atticus

A mimimal API to create asynchronous actors

worker-pool

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

acu

building asynchronous actors

hollywood

actor framework

requiem

Actor framework for Rust

xtor

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

boomerang

Deterministic Middleware for Robotics

wasmcloud

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

backstage

A framework for building data-driven distributed systems

theatre

A concise async actor model implementation

ab-code-gen

Functions to generate boilerplate code for objects implementing the 'Actor' pattern. Used by the abcgen crate.

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

crb-actor

CRB | Composable Runtime Blocks | Actor

cooper

in-process, async Actor library for Rust

mlua_actor

Lua Actor for Rust(sync/async)

lib3h_zombie_actor

lib3h actor request tracking module

aktors

Driver for derive-aktor

theater-cli

Command-line interface for Theater actor system

wick-component

Macros and exports used to create Wick components

murray

A minimal actor definition macro using Tokio

relearn

A Reinforcement Learning library

tractor

Actor system modelled after Pony's actors

mqtt_actor

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

lakka

actors with macros

flo-state

Lightweight actor library

maikklein/unreal-ffi

Rust integration for Unreal Engine 5

actr-mailbox

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

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

riker-cqrs

Command Query Responsibility Separation for Riker applications

fort

Proc macro attributes for Bastion runtime

starlang-core

Core types for Starlang - Erlang-style concurrency for Rust

felicia

service for accessing and sharing lists of bad actors

actix-signal

Manage the lifecycle of an actix actor with its address

wasmind_actor_bindings

WebAssembly component model bindings for Wasmind actors

vino-provider

SDK for native and WASM Vino components

act-locally

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

veecle-os-test

testing actors in Veecle OS

funfsm

An FSM library where the states are functions

agner-sup

An actor toolkit inspired by Erlang/OTP (supervisors)

simple-actor

Helper to write actor-based async code

fibril

implementing distributed systems with commmunicating fibers

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

elfo-core

The core of the elfo system

histrion

A minimal Rust actor library

wasmflow-packet

encapsulating the message packets sent across Wasmflow components

keeshond_treats

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

ringkernel-core

Core traits and types for RingKernel GPU-native actor system

actix-ws-ng

WebSockets for Actix Web, without actors

rosey-actors

Actor framework

elfo-macros-impl

Macros for matching and deriving messages, implementation internals

stronghold-communication

libp2p-noise based communication system for IOTA Stronghold

theater-client

Client library for Theater actor system

agner-utils

An actor toolkit inspired by Erlang/OTP (utils)

herolib-derive

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

heph-rt

speciailised runtime for Heph's actor

toktor

A small tokio-based Actor framework

simple-tokio-watchdog

Pretty simple but bulletproof watchdog actor

atomic-actor

An Actor with async fn handlers

puppet

actor framework which uses no dynamic dispatch or boxing

xacto

Erlang-style actors for Rust

maelstrom_rs

write toy distributed systems with Maelstrom as Actors

theater-server

HTTP server for Theater actor system management

sendfile

wrapper around the sendfile(2) system call

kameo_macros

Fault-tolerant Async Actors Built on Tokio macros

wasmflow-streams

encapsulating the message packets sent across Wasmflow components

nexus-actor-utils-rs

Nexus Actor

xtra-addons

Add-on functionality (Broker, Registry) for crate xtra

wasmflow-boundary

SDK for native and WASM Wasmflow components

wasmflow-output

SDK for native and WASM Wasmflow components

minactor

Minimal actor framework for Rust with tokio

scylladb-parse

Statement parsing library for Scylla CQL

vino-packet

encapsulating the message packets sent across Vino components

wasmflow-collection-link

SDK for native and WASM Wasmflow components

coerce-rt

Async actor runtime

yaaf

Actor Framework

actress

actor library for Rust

wick-packet

Packet, stream, and entity types for Wick, a WebAssembly application flow runtime