---
id: thespian
version: "4.0.1"
license: MIT
license_treatment: permissive
maintenance: aging
---

# thespian — Python Actor concurrency library

License: permissive · Maintenance: aging · Downloads: 135.1K/mo

## What it is and what it does

Thespian is a Python library implementing the Actor Model, a concurrency paradigm where independent actors execute in parallel and coordinate through asynchronous message passing rather than shared state. It enables developers to build applications that are naturally concurrent, can run across multiple machines, and recover from failures by isolating work into separate actors. The framework handles actor lifecycle, message routing, and system coordination, making it suitable for cloud environments where nodes are dynamically added or removed.

The library is designed for applications requiring fault tolerance and scalability without tight coupling between components. Actors are location-independent, meaning the same code can run locally or distributed across a network with minimal changes. It supports CPython and PyPy across multiple Python versions, though the lack of recent releases and high install friction may indicate limited active development.

Use it for:

- Build fault-tolerant microservices where individual actor failures don't crash the entire system.
- Implement distributed systems that scale across multiple machines with location-transparent actor communication.
- Create concurrent applications processing independent tasks asynchronously without managing threads or locks directly.
- Develop cloud-native applications that adapt to dynamic node availability by treating actors as mobile, independent units.
- Prototype actor-based algorithms or systems where message-passing semantics are more natural than shared-memory concurrency.

## Worth the install?

AI-flagged interpretation of the facts above — verify before relying.

Thespian provides an Actor Model framework for building concurrent, distributed, and fault-tolerant applications in Python where independent actors communicate via message passing.

Yes-with-conditions. Thespian is a mature, permissive-licensed framework for actor-based concurrency with no external dependencies, making it lightweight to integrate. However, install friction is high and the project shows signs of aging—no release in 520 days despite Production/Stable status. Install it if you need actor-model semantics and can accept limited active maintenance; avoid it if you require frequent updates or active community support.

## Install

pip install thespian
uv add thespian
poetry add thespian

## Installing thespian

Before you install: High install friction reported. The package has not seen a release in 520 days despite being marked as Production/Stable, and maintenance status is aging. No runtime dependencies to simplify setup, but the long gap since last activity suggests limited ongoing support.

License in practice: MIT license is permissive, allowing broad use including in commercial and proprietary projects with minimal restrictions—only requiring attribution and including the license text.

Quickstart:

pip install thespian

from thespian.actors import Actor, ActorSystem

class HelloActor(Actor):
    def receiveMessage(self, msg, sender):
        self.send(sender, f"Hello from {self.myAddress}")

system = ActorSystem()
hello_ref = system.createActor(HelloActor)
response = system.ask(hello_ref, "Hi", timeout=1)
print(response)

Verify before relying:

- Whether the 520-day gap since last release reflects intentional stability or abandonment of active maintenance.
- Current state of the project repository and whether it remains actively monitored for issues.
- Compatibility testing status with Python 3.10, 3.11, and 3.12 listed in classifiers.

## Package facts

- License: MIT (permissive)
- Python support: unspecified
- Install friction: high
- Maintenance: aging
- Downloads: 135.1K/month (top 15,000 on PyPI)
- Known vulnerabilities: none known

## Tags

actor model framework python, concurrent distributed computing, message passing actors, fault tolerant systems, actor system library, asynchronous actor programming, distributed actor framework, actor-model, distributed-systems, fault-tolerance

[View on SkillFed](https://skillfed.io/packages/thespian) · [View on PyPI](https://pypi.org/project/thespian/)