Distributed Python tasks.
Zero brokers.
FastWorker is a brokerless task queue for Python. No Redis. No RabbitMQ. Just 2–3 Python processes, a built-in web dashboard, and native FastAPI integration.
Three steps. Three terminals.
Define tasks, start the control plane, submit from your app. No broker setup, no YAML.
Write a task module
# mytasks.py
from fastworker import task
@task
def add(x: int, y: int) -> int:
return x + y
@task
def send_email(to: str, body: str) -> bool:
# ... your logic
return TrueStart the control plane
# Terminal 1: start the control plane
# (GUI auto-starts at http://127.0.0.1:8080)
fastworker control-plane --task-modules mytasks
# Terminal 2+: add subworkers for scale
fastworker subworker \
--worker-id w1 \
--control-plane-address tcp://127.0.0.1:5555 \
--base-address tcp://127.0.0.1:5561 \
--task-modules mytasksCall from FastAPI
# app.py (FastAPI example)
from fastapi import FastAPI
from fastworker import Client
app = FastAPI()
client = Client()
@app.on_event("startup")
async def _start():
await client.start()
@app.post("/add/{x}/{y}")
async def add(x: int, y: int):
task_id = await client.delay("add", x, y)
return {"task_id": task_id}Everything you need. Nothing you don't.
Task queues usually mean orchestrating 4–6 services. FastWorker is 2–3 Python processes with sensible defaults.
Brokerless Architecture
No Redis, RabbitMQ, or Kafka. FastWorker uses direct Python-to-Python NNG messaging. One less service to run, monitor, and secure.
Built-in Management GUI
Real-time Vue + Tailwind dashboard ships with the control plane. Monitor workers, queues, and task history out of the box at port 8080.
FastAPI Native
Submit tasks from async request handlers with one line. Non-blocking submission, result polling, and task-completion callbacks.
Automatic Worker Discovery
Subworkers find the control plane and register automatically. Scale horizontally by spawning more processes — zero reconfiguration.
Priority Queues
Four priority levels (critical, high, normal, low) with automatic load balancing to the least-loaded subworker.
OpenTelemetry Support
Drop-in distributed tracing and metrics. Plug into Jaeger, Honeycomb, or any OTLP collector to trace a task end to end.
How it stacks up
FastWorker trades extreme scale for operational simplicity. It's the pragmatic choice for teams shipping FastAPI services at 1K–10K tasks/min.
| Capability | FastWorker | Celery | RQ | Dramatiq |
|---|---|---|---|---|
| External broker | None | Redis / RabbitMQ | Redis | Redis / RabbitMQ |
| Services to run | 2–3 Python procs | 4–6+ | 3–4 | 3–5 |
| Built-in dashboard | Yes | Flower (separate) | rq-dashboard | Third-party |
| Priority queues | 4 levels built-in | Configurable | Multi-queue | Multi-queue |
| FastAPI integration | Native async | Sync wrapper | Sync wrapper | Sync wrapper |
| Setup time | < 5 minutes | 30+ minutes | 15 minutes | 15 minutes |
From the knowledge base
Guides, comparisons, and articles on FastAPI, async Python, and task-queue architecture.
The NNG control-plane architecture, explained
A deep dive into FastWorker's internals — how NNG socket patterns, a first-class control plane, and in-memory dispatch combine into a brokerless task queue.
Why we built a brokerless task queue
The backstory of FastWorker — why we decided Python deserved a task queue with zero external services, and what we learned shipping it.
FastWorker vs Celery
Honest, detailed comparison of FastWorker and Celery — setup, features, scalability, failure modes, and when to choose each for Python task queueing.
FastWorker vs RQ
Comparing FastWorker and RQ (Redis Queue) — simplicity, features, FastAPI integration, and when to choose each for Python background jobs.
FastWorker vs Dramatiq
Comparing FastWorker and Dramatiq — two modern Python task queues aimed at simplicity, and when to reach for each.
Observability with OpenTelemetry in FastWorker
How to trace FastWorker tasks end-to-end with OpenTelemetry, from a FastAPI request through task execution on a subworker, and how to wire it into Jaeger or Honeycomb.
Ship production FastAPI faster.
Work directly with Dipankar Sarkar, the maintainer of FastWorker, on FastAPI architecture reviews, async migrations, background-job design, and performance audits for Python teams shipping at scale.