ractor
A actor framework for Rust
gix-actor
A way to identify git actors
kameo
Fault-tolerant Async Actors Built on Tokio
crb
CRB | Composable Runtime Blocks
spawned-concurrency
Spawned Concurrency
rsactor
Efficient In-Process Actor Model Implementation for Rust
aqueue
fast speed thread safe async execute queue
rivetkit-client-protocol
Client protocol types for RivetKit
rivetkit
Rust SDK for RivetKit actors, actions, events, queues, and test harnesses
ractor_actors
actors built with Ractor
tcpclient
Asynchronous tcpclient based on aqueue actor
hannibal
A small actor library
ringkernel-cuda
CUDA backend for RingKernel - NVIDIA GPU support via cudarc
rivetkit-inspector-protocol
Inspector protocol types for RivetKit
subtr-actor
Rocket League replay transformer
rivet-envoy-client
Envoy client transport for Rivet actor hosts
rivet-error
Structured error helpers for Rivet
acktor
Pure-Rust actor framework built on top of the Tokio async runtime
rivetkit-engine-process
Resolves, spawns, and reuses the rivet-engine subprocess for local hosts and the CLI
actix
Actor framework for Rust
rivet-depot-client
Depot-backed native SQLite VFS client
rivetkit-shared-types
Shared public types for RivetKit crates
tonari-actor
A minimalist actor framework aiming for high performance and simplicity
act_rs
Act.rs is a minimal actor framework
pasta_lua
Pasta Lua - Lua integration for Pasta DSL
maiko
Lightweight event-driven actor runtime with topic-based pub/sub for Tokio
mm1-address
An Erlang-style actor runtime for Rust
kameo_actors
actors for kameo
rivetkit-actor-persist
Versioned persistence protocol types for RivetKit actors
obzenflow-fsm
Async-first Finite State Machine library inspired by Akka (Classic) FSM
stakker
A lightweight low-level single-threaded actor runtime
actr-framework-protoc-codegen
Protoc plugin for generating actr-framework code from protobuf definitions
dstate
Distributed state replication across actor-based clusters
murmer
A distributed actor framework for Rust
datum-core
Rust stream-processing library mirroring Akka/Pekko Streams Typed, built on Ractor actors
tokio-actors
Zero-ceremony, Tokio-native actors with strong typing and production-ready edge case handling
rivet-metrics
Prometheus metric helpers for Rivet crates
acton-ern
handling Acton Entity Resource Names (ERNs), providing tools for generating, parsing, and managing ERNs within Acton Reactive-based solutions
hydra
A framework for writing fault tolerant, highly scalable applications with the Rust programming language
async-curl
An asynchronous implementation to perform curl operations with tokio
rivet-util-serde
Serde helpers shared by Rivet crates
ghost_actor
GhostActor makes it simple, ergonomic, and idiomatic to implement async / concurrent code using an Actor model
mm1-proto-system
An Erlang-style actor runtime for Rust
actr
Actor-RTC: A WebRTC-native actor framework for distributed real-time systems
nmp-core
NMP kernel substrate: actor runtime, state, capabilities, action registry, snapshots, and protocol extension seams
await-tree
Generate accurate and informative tree dumps of asynchronous tasks
ringkernel-ecosystem
Ecosystem integrations for RingKernel - actors, web frameworks, data processing, ML
ractor_cluster
Distributed cluster environment of Ractor actors
act_rs_smol
Act.rs smol is a minimal smol oriented actor framework
acto
light-weight Actor library for Rust
evno
A high-performance event bus for asynchronous tasks and event-driven systems
ector
open source async, no-alloc actor framework for embedded devices
actr-service-compat
Actor service protocol compatibility analysis using semantic proto schema comparison
keri-core
Core library for the Key Event Receipt Infrastructure
mm1
An Erlang-style actor runtime for Rust
kathputli
Minimal typed-mailbox actor framework over Tokio — actors respond to messages like puppets to strings
jesterky-actor
jesterky host-side SDK: seam trait helpers, test doubles, and the replay driver
mm1-runnable
An Erlang-style actor runtime for Rust
act_rs_tokio
Act.rs Tokio is a minimal Tokio oriented actor framework
actr-protocol
Unified protocol, types, and URI parsing for Actor-RTC framework
tcp-channel-client
Asynchronous tcpclient based on aqueue actor
reflow_pack_cli
reflow-pack— command-line tool to build, inspect, and unpack .rflpack actor bundles
actr-platform-traits
Platform abstraction traits for Actor-RTC: KvStore, CryptoProvider, PlatformProvider
datum-persistence
Event sourcing, durable state, and CQRS persistence for Datum
rivetkit-client
Rust client for RivetKit - the Stateful Serverless Framework for building AI agents, realtime apps, and game servers
xan-actor
Akka actor
rtactor
An Actor framework specially designed for Real-Time constrained use cases
apocalypse
actor framework for Rust
tokio_gen_server
Elixir/Erlang-GenServer-like actor on the Tokio runtime
actr-web-protoc-codegen
Protoc plugin for generating actr-web code from protobuf definitions
ryu-realtime
Room-keyed realtime fan-out primitive for Ryu: a transport-agnostic RoomRegistry mapping room_id -> a per-room tokio actor that owns isolated ephemeral state (presence map + idle clock)…
elfo-test
Test utils for the elfo system
joerl
An Erlang-inspired actor model library for Rust
steady_state
Framework for building long running low latency actor based services on Linux. Provides visual telemetry to watch data flows between actors. Uses Erlang style supervisors to defend…
elfo-configurer
Loads and distributes configs across the elfo system
acty
A lightweight, async actor framework built on Tokio
atomr-remote
Cross-process and cross-host actor messaging for atomr — TCP transport, framed PDU codec, ack'd delivery, endpoint state machine, watcher
acton-ai
An agentic AI framework where each agent is an actor
jesterky-model
Model-backed host actors for jesterky: the ModelActor seam adapter + the codex (ChatGPT-bundle) model. This is the M1->M2 step — a real Actor to swap in for FakeActor.
ringkernel-cpu
CPU backend for RingKernel - testing and fallback implementation
uactor
The fastest and most modular actor system that doesn't force you to pay for what you don't need
archy
An async application framework with services, systems, and dependency injection
actor-helper
Helper library for building actor systems
mra
A lightweight framework for building headless, programmable AI agents in Rust. Tokio-native runtime with built-in supervision, sessions, and tool use.
lane_switchboards
Telecom-inspired OTP actor runtime for Rust: mailbox routing, supervision trees, let-it-crash fault isolation, and distributed messaging
actorizor
macro based actor framework for Tokio-based apps
f2
Official crate for the ff language
elfo
An asynchronous distributed actor framework with robust observability
ringkernel
GPU-native persistent actor model framework - Rust port of DotCompute Ring Kernel
ringkernel-metal
Metal backend for RingKernel - Apple GPU support
theater
A WebAssembly actor system for AI agents
reflow_rt
The public Rust runtime crate for building and running Reflow graph workflows
rakka-core
Actors, supervision, dispatch, mailboxes, scheduler, FSM, event stream, and coordinated shutdown — the core of the rakka actor runtime
reflow_actor
Actor trait, message types, ports, state, and stream handles for the Reflow runtime
reflow_pack_sdk
Author-facing crate for building Reflow actor packs — safe wrapper over the pack ABI plus the #[reflow_pack] macro
atomr
Native Rust runtime for actor-based concurrent and distributed systems. Umbrella crate — pull in subsystems via feature flags.
rakka-remote
Cross-process and cross-host actor messaging for rakka — TCP transport, framed PDU codec, ack'd delivery, endpoint state machine, watcher
pilatus
Modular, extendable application framework for deterministic simulation of autonomous subsystems
rivet-envoy-protocol
Versioned Envoy protocol types for Rivet actor hosts
kameo_console
Terminal UI for monitoring a running kameo actor system
ma-zscheme-ipfs
IPFS-backed DotRegistry for ma-zscheme
elfo-telemeter
Collects and exposes metrics of the elfo system
rivet-depot-client-types
Shared SQLite execution types for depot client
ractor-supervisor
Supervisor module for ractor framework
rakka-inference-remote-core
Remote-provider infrastructure for rakka-inference — distributed rate limiter (CRDT), circuit breaker, retry/backoff, SSE parser, session lifecycle
actr-runtime-mailbox
Persistent mailbox layer for the Actor-RTC framework, backed by SQLite
atomr-infer-remote-core
Remote-provider infrastructure for atomr-infer — distributed rate limiter (CRDT), circuit breaker, retry/backoff, SSE parser, session lifecycle
gabriel2
Indeed, an actor library based on Tokio, written in Rust
tokactor
A actor model framework wrapped around tokio
bastion
Fault-tolerant Runtime for Rust applications
actr-version
Protocol compatibility analysis library using semantic proto analysis
theater-chain-format
Human-readable text format for Theater chain events. Lossless encode/decode of
ChainEventto/from a line-oriented EVENT-block format with embedded Pack Value literals.
xtra
A tiny actor framework
rakka-di
Dependency-injection container for rakka
reflow_rt_capi
C ABI bindings for the Reflow runtime — the shared native surface consumed by Go (cgo), Kotlin/Java (JNI), and other non-Rust callers
reflow_graph
Graph data structures for Reflow — nodes, edges, IIPs, exports, and analysis
theta
Actor Framework
rakka-discovery
Pluggable service-discovery interface for rakka
actr-hyper
Hyper — Actor platform infrastructure: sandbox, transport, scheduler, WASM engine, signing, AIS bootstrap, persistence & crypto primitives
moduforge-persistence
moduforge 持久化
rakka-accel
Backend-agnostic compute-acceleration core. Defines the AccelBackend trait, AccelRef<T> typed pointers, AccelError enum, and CompletionStrategy — the abstraction layer that lets rakka-accel-cuda (NVIDIA)…
ma-zscheme-yaml
YAML/file-backed DotRegistry for ma-zscheme
palladium-plugin-api
Zero-dependency C ABI types for Palladium plugin boundaries
myriam
Actor model implementation for local and remote actors
rakka-cluster-sharding
Sharded entities for rakka — allocation strategies, rebalance, three-phase handoff, remember-entities
reflow_pack_loader
Runtime loader for .rflpack actor bundles — dlopens pack cdylibs and publishes their templates to the runtime registry
moduforge-rules-expression
moduforge 表达式规则
pupactor
actor model library built with tokio
interthread
Auto implementation of the Actor Model
mm1-common
An Erlang-style actor runtime for Rust
atomr-infer
Multi-runtime GPU + remote inference as a supervised actor system on atomr. Single-crate rollup that re-exports per-runtime backends behind feature flags.
theater-handler-supervisor
Supervisor handler for Theater WebAssembly runtime - child actor management
ringkernel-wgpu
WebGPU backend for RingKernel - cross-platform GPU support
theater-handler-message-server
Message server handler for Theater WebAssembly runtime
palladium-federation
Distributed cluster membership and federated actor registry for Palladium
reflow_api_services
Generated API-service actor catalog for Reflow — thousands of actors across ~90 third-party services
horsie-actor
Actor primitives with durable journaling for horsie
wasm-actor-bridge
Typed, zero-copy Web Worker bridge for Rust/WASM actor systems
datum-cluster-sharding
Datum cluster sharding core: envelopes, coordinator, regions, and entities
whisk
fast lockless async channels
actr-cli
Command line tool for Actor-RTC framework projects
bombay-address
A generic concurrent address space with generation-safe ownership
moduforge-rules-template
moduforge 模板规则
pulsing-actor
Lightweight distributed actor framework for Pulsing
wasmcloud-interface-httpserver
interface for actors to receive http requests (wasmcloud:httpserver)
mm1-logger
An Erlang-style actor runtime for Rust
acton_test
Testing utilities for Acton actors, providing tools to help in the testing and validation of actor behavior
rakka-persistence-mongodb
MongoDB journal and snapshot store for rakka — indexed collections, atomic multi-document inserts, BSON payloads
moduforge-collaboration-client
moduforge 协作系统
multi-stash
Vector-based arena data structure that reuses vacant slots
wasmcloud-interface-httpclient
interface for actors to issue http/https requests (wasmcloud:httpclient)
atomr-cluster-sharding
Sharded entities for atomr — allocation strategies, rebalance, three-phase handoff, remember-entities
rakka-inference-runtime
Runtime-agnostic actor topology for rakka-inference — gateway, request actor, dp-coordinator, engine-core, two-tier worker, placement, deployment manager, metrics
may_actor
Actor library based on MAY
starlang
Erlang-style concurrency for Rust
reflow_network
Network executor for Reflow — routes messages between actors, manages subgraphs, and emits runtime events
theater-handler-runtime
Core runtime handler for Theater WebAssembly runtime - logging, state, lifecycle
kerberos_constants
Constants used by differente objects and actors of the Kerberos protocol
mm1-proto-network-management
An Erlang-style actor runtime for Rust
heph
actor framework based on asynchronous functions
p2panda-spaces
Data encryption for multi-device groups
atomr-discovery
Pluggable service-discovery interface for atomr
websocketing
WebSockets actor framework
edp_node
High-level Erlang Distribution Protocol node implementation
fraktor-rs
Specification-driven actor runtime bridging Akka/Pekko and Proto.Actor semantics across no_std and std targets
atomr-persistence-query
Tagged event-stream queries over atomr journals
wasmcloud-interface-numbergen
interface for actors to generate random numbers and guids (wasmcloud:builtin:numbergen)
atomr-testkit
Test scaffolding for atomr actors — TestProbe matchers, TestKit, virtual-time scheduler, multi-node spec, EventFilter
agentor
Agent-native Actor runtime — an Actor-model execution platform designed for AI Agents
smol-workflow-engine
smol-workflows engine
tiny-tokio-actor
tiny actor library on top of tokio
truba
The minimal tokio runtime based actors for Rust
heph-inbox
Bounded capacity channel designed to be used as inbox for actors. Also supports one shot channels.
postvan
A minimalistic implementation of pub/sub messaging
tf-bridge-aws
TrustForge identity bridge for AWS. Translate AWS credentials, roles, and policies into cryptographic TrustForge actors and capabilities.
tf-bridge-doppler
TrustForge identity bridge for DOPPLER. Translate DOPPLER credentials, roles, and policies into cryptographic TrustForge actors and capabilities.
rakka-dashboard
Live web UI over a running rakka system — REST + WebSocket + embedded React SPA, Prometheus / OTLP exporters
tower-actor
A
towermiddleware that creates aServiceby passing messages to an actor
mm1-server
An Erlang-style actor runtime for Rust
palladium-transport
TCP, QUIC, and in-process transports for Palladium actors
codas-flow
Low-latency, high-throughput bounded queues ("data flows") for (a)synchronous and event-driven systems
palladium-runtime
High-performance multi-core actor runtime for Palladium
sombrax-actors
A lightweight actor framework with broadcast and work-queue channels, shared state, and derive macros for message-driven Rust systems
actionqueue-actor
Remote actor registration, heartbeat monitoring, and capability routing for the ActionQueue task queue engine
crb-agent
CRB | Composable Runtime Blocks | Agent
reflow_components
Standard component catalog for Reflow — procedural, media, GPU, animation, I/O, and stream actors
mm1-multinode
An Erlang-style actor runtime for Rust
theater-server-cli
Standalone CLI for Theater server management
rakka-inference-runtime-litellm
LiteLLM proxy provider for rakka-inference — implements ModelRunner against the LiteLLM unified API gateway, fronting OpenAI-compatible endpoints for any provider LiteLLM supports
elfo-utils
Some utils for the elfo system
atomr-profiler
Cross-runtime actor profiler for atomr — same scenarios in Rust and Python with a shared JSON schema
atomr-persistence-tck
Conformance test suite for atomr-persistence journal and snapshot implementations
mofa-runtime
MoFA Runtime - Message bus, agent registry, and event loop
cineyma
A lightweight actor framework for Rust with typed messages, OTP-style supervision, and distributed clustering
dactor
An abstract framework for distributed actors in Rust
mangadex-desktop-api2
A Actix server for downloading manga, chapters, covers from Mangadex
vin
An ergonomic actor framework
spaad
Zero boilerplate actor systems with xtra
pptr
Type-Driven Asynchronous Actor Runtime
atomr-infer-runtime-anthropic
Anthropic Messages API provider for atomr-infer — implements ModelRunner against api.anthropic.com, with cost table, error classification, and SSE streaming
crb-send
CRB | Composable Runtime Blocks | Send
tf-bridge-azure
TrustForge identity bridge for AZURE. Translate AZURE credentials, roles, and policies into cryptographic TrustForge actors and capabilities.
explore-os
An actor system exposed as filesystem
apify-rs
client for the Apify API
xactor
actors framework based on async-std
mm1-node
An Erlang-style actor runtime for Rust
actr-platform-native
Native platform provider for Actor-RTC: SQLite storage, ed25519-dalek crypto, filesystem operations
palladium-http
HTTP listener integration for the Palladium actor runtime
bastion-executor
Cache affine NUMA-aware executor for Rust
tf-bridge-gcp
TrustForge identity bridge for GCP. Translate GCP credentials, roles, and policies into cryptographic TrustForge actors and capabilities.
reifydb-core
Core database interfaces and data structures for ReifyDB
luciole
Actor runtime + DAG execution engine. WASM-safe, deadlock-aware, with pipe_to, WaitGraph, and streaming pipelines.
rakka-inference-runtime-gemini
Google Gemini provider for rakka-inference — implements ModelRunner against Vertex AI and AI Studio endpoints, with cost table, error classification, and SSE streaming
mm1-sup
An Erlang-style actor runtime for Rust
messages
Runtime-agnostic actor library
atomr-accel-tensorrt
TensorRT engine builder + runtime as supervised atomr actors. Wraps libnvinfer / libnvonnxparser at runtime (proprietary library, not vendored). ONNX import, INT8/FP8 PTQ calibration…
atomr-di
Dependency-injection container for atomr
guitite
fast easy to use loro-sync-protocol build on top of actix
rakka-inference-runtime-anthropic
Anthropic Messages API provider for rakka-inference — implements ModelRunner against api.anthropic.com, with cost table, error classification, and SSE streaming
actix-remote
ergonomic remote actors via actix and canary
acmap
An actor-style sharded async map inspired by DashMap-like APIs
palladium-plugin
Native (cdylib) and WASM plugin system for Palladium actors
atomr-persistence-query-inmemory
In-memory read journal for atomr-persistence-query
mdstream-tokio
Tokio glue for mdstream (delta coalescing and optional actor helpers)
lifeline
dependency injection library for asynchronous message-based applications
rukko
communicating with JVM-based Pekko actors
actix-mqtt-client
A MQTT client based on the actix framework
theater-handler-loop
Loop handler for Theater WebAssembly runtime - cooperative looping with yield points
atomr-hosting
Builder API for wiring a atomr system together — config, DI, setup hooks
theater-handler-timer
Timer handler for Theater WebAssembly runtime - periodic tick callbacks
mm1-test-rt
An Erlang-style actor runtime for Rust
tycode-core
Core chat actor and AI functionality for TyCode
actr-runtime
Thin business dispatch layer for Actor-RTC — wasm32-compatible
prax-actix
Actix-web framework integration for Prax ORM
fraktor-utils-core-rs
Portable no_std toolbox primitives for the fraktor actor runtime
starlang-runtime
Runtime infrastructure for Starlang - process registry, scheduler, mailboxes
wasmcloud-interface-blobstore
Interface for accessing an object store over the wasmcloud:blobstore contract
fraktor-utils-std-rs
Standard-library helpers complementing fraktor-utils-core
mm1-ask
An Erlang-style actor runtime for Rust
theater-handler-assembler
Actor assembler handler for Theater WebAssembly runtime
thespis
The interface of the thespis actor model (contains only traits)
strontium-palladium
Deterministic fault-bridge contracts for Palladium actor simulations under Strontium control
Try searching with DuckDuckGo.