Keep your app fast — run slow work in the background.
A task queue with no message broker. Your app hands slow work — sending email, processing uploads, running pipelines — to a background worker and gets the result later; the queue, results, and schedules all live in one SQLite file (scale to Postgres). First-class Python, Node, and Java over one Rust core.
from flexiq import Queue queue = Queue(db_path="tasks.db") @queue.task(max_retries=3) def add(a: int, b: int) -> int: return a + b job = add.delay(2, 3) print(job.result()) # → 5
From .delay() to result
Your application code enqueues a job. The Rust scheduler hands it to a worker. The result lands back in the shared store — same core, same queue, no broker in the middle, whichever SDK you called it from.
Tell us what's going wrong
Not sure you need a task queue? Pick the problem that sounds like yours — flexiq shows you how it handles it, with the exact code and a live demo you can try.
Hand it off, return instantly, stream the progress back
Never make a user watch a spinner. Push the work into flexiq, respond in milliseconds, and report a live percentage as it runs.
- Respond now
.delay()queues the job and your endpoint returns immediately - Report progresscall
progress.update()from inside the task - User sees it moveyour UI subscribes and shows a live % bar
@queue.task def process(file_id): for i, chunk in enumerate(chunks): crunch(chunk) progress.update((i+1)/total) # ← live %
The convenience of Celery, the performance of Rust
Everything you need to run background jobs in production — and nothing you don't.
Brokerless
No Redis, no RabbitMQ. Everything in a single SQLite file — queue, results, rate limits, schedules. Just pip install or pnpm add and go.
Rust-powered
The scheduler, dispatcher, and storage engine are all Rust. Tokio runtime, OS-thread worker pool; thin PyO3, napi-rs and JNI boundaries keep per-SDK overhead negligible.
One core, native SDKs
First-class Python, Node.js and Java clients are peers over the same Rust core and store — enqueue in one runtime, run workers in another. Zero cross-language dependency.
DAG workflows
Multi-step pipelines as directed acyclic graphs. Fan-out, fan-in, conditions, approval gates, sub-workflows, incremental re-runs, Mermaid viz.
Resource system
Inject database connections, HTTP clients, and cloud SDKs by name. Three-layer pipeline: argument interception, worker DI, transparent proxy.
Production-ready
Retries with exponential backoff, dead letter queue, rate limits, circuit breakers, distributed locks, structured logs, OTel/Sentry/Prometheus.
Built for the jobs you actually have
Pick the workload — flexiq ships the primitives.
ETL pipelines →
Chain extract → transform → load as a DAG. Fan out across workers, fan in to aggregate, restart from any node on failure.
Email & notifications →
Bursty SMTP, push, or webhook delivery. Per-task rate limits keep providers happy; retries with backoff handle transient failures.
ML inference & batch →
Long-running model jobs with progress tracking, soft timeouts, and prefork pools for true CPU parallelism without GIL contention.
Scheduled jobs →
Six-field cron syntax down to the second. Periodic tasks live in the scheduler — no separate beat daemon to babysit.
Less to operate
The same task, two stacks. Side by side, with the operational delta.
| flexiq | Celery + Redis | |
|---|---|---|
| Install | pip install flexiq | pip install celery[redis] + run Redis daemon |
| Background services | 1 (worker) | 3 (worker, beat, Redis) |
| Default storage | SQLite file (built-in) | Redis (separate daemon) |
| Retry config above | max_retries=3 decorator arg | try/except + self.retry(exc=…) |
Slots into your stack
First-class support for the tools you already run.
Python frameworks
Node frameworks
Storage
Observability
Five minutes from install to your first job.
The quickstart walks you through defining a task, enqueuing it, and watching the worker run it — in the SDK you already use, no Redis, no broker, no config.