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

nexus-actor-core-rs

Core library for Nexus Actor

ractor_actors

actors built with Ractor

act_rs

Act.rs is a minimal actor framework

await-tree

Generate accurate and informative tree dumps of asynchronous tasks

rtactor

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

tonari-actor

A minimalist actor framework aiming for high performance and simplicity

stakker

A lightweight low-level single-threaded actor runtime

moduforge-rules-expression

moduforge 表达式规则

evno

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

ghost_actor

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

cao-lang

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

nexus-actor-utils-rs

Nexus Actor

starlang

Erlang-style concurrency for Rust

elfo

An asynchronous distributed actor framework with robust observability

xan-actor

Akka actor

ractor-supervisor

Supervisor module for ractor framework

async-curl

An asynchronous implementation to perform curl operations with tokio

theta

Actor Framework

cineyma

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

moduforge-rules-template

moduforge 模板规则

joerl

An Erlang-inspired actor model library for Rust

ractor_cluster

Distributed cluster environment of Ractor actors

archy

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

kameo_actors

actors for kameo

acton-ern

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

fluxion

actor framework written in rust and designed for distributed systems

actr-version

Protocol compatibility analysis library using semantic proto analysis

ringkernel-metal

Metal backend for RingKernel - Apple GPU support

vuo

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

acto

light-weight Actor library for Rust

acty

A lightweight, async actor framework built on Tokio

nexus-actor-remote-rs

Remote library for Nexus Actor

apocalypse

actor framework for Rust

codas-flow

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

moduforge-persistence

moduforge 持久化

maiko

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

fraktor-rs

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

actr-protocol

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

rukko

communicating with JVM-based Pekko actors

actix-telepathy

Cluster extension for the actix actor framework

myriam

Actor model implementation for local and remote actors

common-game

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

actr-framework-protoc-codegen

Protoc plugin for generating actr-framework code from protobuf definitions

truba

The minimal tokio runtime based actors for Rust

mdstream-tokio

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

moduforge-collaboration-client

moduforge 协作系统

ringkernel-cpu

CPU backend for RingKernel - testing and fallback implementation

actr

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

moonpool

A place to experiment around actors

ringkernel-wgpu

WebGPU backend for RingKernel - cross-platform GPU support

superqueue

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

gabriel2

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

tokactor

A actor model framework wrapped around tokio

actor-helper

Helper library for building actor systems

actr-cli

Command line tool for Actor-RTC framework projects

bastion

Fault-tolerant Runtime for Rust applications

prax-actix

Actix-web framework integration for Prax ORM

xtra

A tiny actor framework

tcpclient

Asynchronous tcpclient based on aqueue actor

may_actor

Actor library based on MAY

tiny-tokio-actor

tiny actor library on top of tokio

wasmcloud-interface-httpserver

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

tokio-actors

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

starlang-runtime

Runtime infrastructure for Starlang - process registry, scheduler, mailboxes

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

starlang-gen-server

GenServer pattern for Starlang

gmt_dos-clients_transceiver

GMT DOS Transmitter/Receiver Clients

starlang-supervisor

Supervisor pattern for Starlang

fraktor-utils-core-rs

Portable no_std toolbox primitives for the fraktor actor runtime

ascolt

Async runtime-agnostic actor framework

whisk

fast lockless async channels

pupactor

actor model library built with tokio

theater

A WebAssembly actor system for AI agents

mailboxxy

micro actor library for rust

starlang-process

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

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)

kerberos_constants

Constants used by differente objects and actors of the Kerberos protocol

act_rs_tokio

Act.rs Tokio is a minimal Tokio oriented actor framework

multi-stash

Vector-based arena data structure that reuses vacant slots

priact

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

elfo-test

Test utils for the elfo system

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

awol2005ex_kerberos_constants

Constants used by different objects and actors of the Kerberos protocol

starlang-application

Application lifecycle management for Starlang

act_rs_smol

Act.rs smol is a minimal smol oriented actor framework

simpl_actor

tokio actors

heph-inbox

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

messages

Runtime-agnostic actor library

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

elfo-network

Distributed actors for elfo

wasmind_actor_loader

Dynamic actor loading and dependency resolution for Wasmind

crb-send

CRB | Composable Runtime Blocks | Send

lifeline

dependency injection library for asynchronous message-based applications

elfo-telemeter

Collects and exposes metrics of the elfo system

wasmind_config

Configuration system for Wasmind actors and runtime

elfo-dumper

Dumps messages of the elfo system on disk

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)

ductile

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

elfo-logger

Logs events of the elfo system

fraktor-actor-core-rs

fraktor no_std actor runtime core

elfo-pinger

Pings groups of the elfo system

elfo-configurer

Loads and distributes configs across the elfo system

act-zero-ext

Macros for act-zero

lua_actor

Lua Actor for Rust(sync/async)

slacktor

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

wasmind_actor_utils_common_messages

Common message types shared between Wasmind actors

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

pipeworks

Robust data processing pipelines

woab

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

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

worker-pool

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

atticus

A mimimal API to create asynchronous actors

acu

building asynchronous actors

veecle-os-test

testing actors in Veecle OS

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

histrion

A minimal Rust actor library

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

starlang-core

Core types for Starlang - Erlang-style concurrency for Rust

fort

Proc macro attributes for Bastion runtime

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

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

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

actix-ws-ng

WebSockets for Actix Web, without actors

xacto

Erlang-style actors for Rust

ringkernel-core

Core traits and types for RingKernel GPU-native actor system

rosey-actors

Actor framework

elfo-macros-impl

Macros for matching and deriving messages, implementation internals

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

theater-client

Client library for Theater actor system

toktor

A small tokio-based Actor framework

agner-utils

An actor toolkit inspired by Erlang/OTP (utils)

heph-rt

speciailised runtime for Heph's actor

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

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

wasmflow-streams

encapsulating the message packets sent across Wasmflow components

kameo_macros

Fault-tolerant Async Actors Built on Tokio macros

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

kythera-actors

Kythera FVM WASM actor builder

wasmflow-traits

encapsulating the message packets sent across Wasmflow components

git-next-server-actor

Server actor for git-next, the trunk-based development manager