Tasker Core

Workflow orchestration in Rust with PostgreSQL-native messaging. Tasker Core provides DAG-based task execution, event-driven coordination, and multi-language worker support for complex workflows.

Status: Early Development — the core engine is functional, published, and under active development. APIs may evolve between minor versions.

Tasker is an orchestration framework for workflows that need more than a job queue but less than a full BPM platform. You define tasks as directed acyclic graphs of steps, and Tasker handles dependency resolution, state management, retry logic, and worker coordination.

• DAG-Based Workflows — Define steps with dependencies; Tasker resolves execution order and parallelism automatically
• PostgreSQL as Source of Truth — All state lives in PostgreSQL. Messaging via PGMQ (zero extra dependencies) or RabbitMQ (high-throughput)
• Event-Driven Coordination — Real-time step discovery with LISTEN/NOTIFY push and polling fallback, and RabbitMQ for high-throughput messaging
• Multi-Language Workers — Write step handlers in Rust, Ruby, Python, or TypeScript. All languages share the same orchestration engine
• Operational Tooling — CLI (tasker-ctl) for task management, health monitoring, DLQ investigation, configuration validation, and project scaffolding

• Order fulfillment workflows with inventory, payment, and shipping coordination
• Data processing pipelines with complex step dependencies and parallel execution
• Payment processing with retry logic and idempotency guarantees
• Microservices orchestration where steps span multiple services

• Simple cron jobs — use native cron or a job scheduler
• Single-step operations — the orchestration overhead isn't justified
• Sub-millisecond latency requirements — Tasker adds ~10-20ms architectural overhead per step

• Rust 1.75+ | PostgreSQL 17+ (uuidv7 support) | Docker (recommended)
• Optional: RabbitMQ (for high-throughput messaging)

# Start PostgreSQL (includes PGMQ extension)
docker-compose up -d postgres

# Run migrations
export DATABASE_URL="postgresql://tasker:tasker@localhost/tasker_rust_test"
cargo sqlx migrate run

# Start orchestration server
docker-compose --profile server up -d

# Create a task
curl -X POST http://localhost:8080/v1/tasks \
  -H "Content-Type: application/json" \
  -d '{"template_name": "linear_workflow", "namespace": "example"}'

# Check health
curl http://localhost:8080/health

Full Guide: docs/guides/quick-start.md

┌─────────────────────────────────────────────────────────────┐
│                     Client Applications                     │
│               (REST API / gRPC / tasker-ctl)                │
└──────────────────────────┬──────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────────┐
│              Tasker Orchestration Server                    │
│    Task Init → Step Discovery → Enqueueing → Finalization  │
└──────────┬──────────────────────────────────┬───────────────┘
           │                                  │
           ▼                                  ▼
┌──────────────────────┐          ┌──────────────────────────┐
│  PostgreSQL + Broker │◄────────►│  Namespace Worker Pools  │
│ (PGMQ or RabbitMQ)   │          │  (Horizontal Scaling)    │
└──────────────────────┘          └──────────────────────────┘

Key Patterns: Dual state machines (12 task + 9 step states), event-driven with polling fallback, autonomous workers, PostgreSQL as source of truth.

Deep Dive: Architecture Documentation

All documentation is organized in the Documentation Hub:

Development Guide: docs/development/ | AI Assistant Context: CLAUDE.md

# Build (always use --all-features)
cargo build --all-features

# Test (requires PostgreSQL running)
cargo test --all-features

# Lint
cargo fmt && cargo clippy --all-targets --all-features

# Run server
cargo run --bin tasker-server

The project uses cargo-make as its task runner. See CLAUDE.md for complete development context including test levels, database operations, and container setup.

Tasker is published across multiple registries:

1. Review CLAUDE.md for project context and conventions
2. Run tests: cargo test --all-features
3. Format and lint before PR: cargo fmt && cargo clippy --all-targets --all-features
4. See the Documentation Hub for documentation structure

MIT License — see LICENSE for details.

Workflow orchestration for teams that need reliability without ceremony.

Quick Start | Documentation | Architecture