Projects sharing features with Bullmq

Sidekiq is a background job processor and queue manager for Ruby that uses Redis to manage asynchronous tasks. It functions as a distributed task scheduler capable of handling periodic, delayed, and recurring jobs across a cluster of worker processes. The project features a job monitoring dashboard and administrative web interface for visualizing system state, tracking worker performance, and managing failed or dead jobs. It provides a distributed rate limiter to control execution frequency across multiple processes. The framework covers a broad range of operational capabilities, including j

Agenda is a persistent background job scheduler and distributed task runner for Node.js applications. It functions as a cron job manager and task queue that ensures background processes survive application restarts by storing job state and metadata in a database. The system coordinates execution across multiple worker instances using distributed locking mechanisms to prevent duplicate processing. It supports flexible scheduling via cron expressions or specific dates and includes a pluggable storage interface for backends such as MongoDB, PostgreSQL, and Redis. The platform provides controls

Resque is a Ruby library for enqueueing and processing asynchronous tasks using Redis as a data store. It functions as a distributed task processor and queue manager, allowing long-running work to be moved out of the main request cycle. The system executes background jobs in isolated child processes to prevent memory leaks and provides a web-based dashboard for monitoring queue depths, worker activity, and failed job statistics. Capability areas include distributed worker coordination via signals, error handling with job retry mechanisms, and priority-ordered queue management. It also suppor

Hazelcast is a distributed data platform that combines an in-memory data grid with a stream processing engine to support real-time analytics and event-driven applications. It functions as a partitioned, distributed key-value store that replicates data across cluster nodes to provide low-latency access and high availability. The platform also serves as a distributed SQL query engine, allowing users to execute standard SQL statements against both in-memory datasets and external data sources. What distinguishes Hazelcast is its use of a distributed consensus subsystem to maintain strongly consis

Faktory is an open-source work server that queues, dispatches, and manages background jobs across multiple programming languages. It stores job payloads as JSON hashes in a Redis-backed queue and provides language-specific client and worker libraries that enable any language to push jobs to the server or fetch and execute them. The server includes a batch workflow orchestrator that groups jobs into batches with completion tracking for coordinating multi-step asynchronous workflows. It features a configurable job uniqueness filter that prevents duplicate enqueues within a time window, an expon

Sidekiq is a Ruby background processing framework and asynchronous task runner. It functions as a Redis-backed background job processor that offloads heavy or time-consuming work from web requests to separate worker processes to ensure the main application remains responsive. The system operates as a Redis task queue, storing pending jobs in Redis to be processed concurrently by multiple threads. It provides a framework for distributed task queueing and asynchronous job scheduling to coordinate work across multiple server instances. The project covers Ruby application scaling by executing ba

Bee-queue is a Node.js background processing system that uses Redis for job queueing and persistence. It is designed to offload heavy tasks from the main execution thread to background workers to maintain application responsiveness. The project provides distributed job processing, allowing worker nodes to run across multiple processes to handle large volumes of tasks concurrently. It ensures reliable task execution through automatic retries and the recovery of stalled processes. Its capability surface covers asynchronous task scheduling for delayed jobs, concurrency control for worker nodes,

APScheduler is a Python task scheduler designed to execute functions at specific times or recurring intervals. It functions as an asynchronous background scheduler and distributed job dispatcher, allowing tasks to run concurrently with application lifecycles and web server request handling. The system distinguishes itself through a persistent job store that saves schedules and task states in external databases, ensuring continuity across process restarts. It separates task scheduling from execution by dispatching jobs to distributed workers in separate processes to prevent execution bottlenec

Temporal is a distributed workflow orchestration engine designed to manage fault-tolerant, stateful, and long-running background processes. It functions as a platform for coordinating complex cross-service operations, ensuring consistency and reliability in distributed environments by decoupling workflow orchestration from task execution. The platform distinguishes itself through a deterministic, event-sourced execution model that reconstructs workflow state by re-executing code from an immutable event log. This approach isolates non-deterministic side effects into managed activities, allowin

gocron is a task scheduling library for Go designed to automate recurring tasks using crontab expressions, fixed durations, and specific calendar dates. It functions as a concurrent job manager and execution monitor that tracks task lifecycles and performance. The project provides distributed task scheduling through leader election and distributed locking to prevent duplicate job execution across multiple nodes. It further distinguishes itself with a concurrency management system that implements singleton constraints and global execution quotas to protect system resources. The scheduler cove

Redis is a high-performance in-memory key-value store that functions as a distributed cache, message broker, and NoSQL database. It provides sub-millisecond read and write access to data stored in RAM and can operate as a vector database for indexing high-dimensional embeddings. The system supports a wide range of data storage and synchronization primitives, including the management of strings, hashes, lists, sets, and JSON documents. It enables real-time data operations through atomic transactions, hybrid persistence using snapshots and append-only logs, and high-availability configurations

pg-boss is a background task scheduler and distributed task queue that uses PostgreSQL as a reliable message broker for asynchronous job processing. It provides a system for distributing work across multiple application instances, ensuring exactly-once delivery through atomic database transactions. The project includes a cron job scheduler for automating recurring tasks and a PostgreSQL pub-sub system for fan-out event distribution. It also features a web-based management dashboard for monitoring queue statistics and controlling job lifecycles, including manual retries and cancellations. Cap

Kue is a Redis-backed job queue library for Node.js that provides a complete system for defining, scheduling, and processing background work. It stores job metadata and state in Redis lists and sorted sets, enabling persistent, in-memory operations with configurable concurrency control and priority-sorted processing. The library includes a RESTful HTTP API for managing jobs and a web-based monitoring dashboard for inspecting job status, progress, and logs. The system distinguishes itself through its event-driven worker model, where workers listen for job events via Redis pub/sub and process j

Hyperf is a high-performance PHP coroutine framework designed for building microservices and middleware. It utilizes non-blocking coroutines to handle high concurrency and low-latency request processing, providing a foundation for scalable distributed systems. The framework is distinguished by an aspect-oriented programming based dependency injector that enables pluggable components and meta-programming. It includes a coroutine-optimized object-relational mapper with integrated model caching and an orchestration toolkit for microservice governance, featuring service discovery, circuit breaker

Inngest is a durable execution framework and event-driven automation engine designed to orchestrate background workflows. It enables developers to build resilient, stateful processes by memoizing function steps, ensuring that long-running tasks can automatically resume from the last successful operation after failures, timeouts, or infrastructure restarts. The platform distinguishes itself through its event-driven architecture, which uses a schema-validated bus to trigger functions and coordinate complex, multi-step logic. It employs an onion-model middleware approach for cross-cutting concer

Asynq is a distributed background job processing framework for Go applications. It manages asynchronous task queues by offloading heavy operations to persistent storage, allowing the main application to remain responsive while background workers handle workloads. The system utilizes Redis to manage task state, concurrency, and message distribution across multiple worker instances. It employs atomic Lua scripting and sorted sets to ensure reliable job acquisition, precise scheduling of delayed tasks, and fault-tolerant processing through a two-stage acknowledgement flow. The framework support

RoadRunner is a high-performance application server and process manager designed to serve PHP applications using a persistent worker model. It eliminates bootload overhead and initialization time by keeping application processes alive between requests, acting as a protocol-agnostic proxy that routes traffic to a pool of supervised workers. The server is built with a plugin-based modular architecture, allowing it to be extended with custom Go plugins and compiled into tailored binaries. It distinguishes itself by providing a unified execution model for a wide array of communication protocols,

Quartz.NET is a job scheduler for .NET applications designed to schedule and execute programmatic tasks. It functions as a distributed task orchestrator and enterprise task orchestrator, capable of managing recurring jobs with concurrency limits and complex intervals. The system provides high availability through a clustered execution model that balances loads and provides fail-over redundancy across multiple server instances. It utilizes a relational database job store to persist job and trigger states, ensuring that scheduled tasks survive application restarts. The framework includes capab

Elsa Core is a workflow engine framework designed for defining, executing, and managing long-running business processes. It functions as a distributed workflow orchestrator and event-driven trigger system, capable of operating as a multi-tenant platform with secure data isolation. The project distinguishes itself through a flexible approach to workflow definitions, supporting a visual drag-and-drop designer, programmatic C# definitions, and portable JSON specifications. It provides a highly extensible architecture allowing for the development of custom activities and the use of a dynamic expr

Hatchet is an open-source durable workflow engine and task orchestration platform. It provides a framework for building and executing fault-tolerant, multi-step pipelines as directed acyclic graphs (DAGs), with automatic retries, scheduling, and real-time observability. The system is built around durable task checkpointing, which persists execution state after each step so work can resume from the last checkpoint after a worker crash or restart, and it supports event-driven task resumption that pauses a task until a matching external event arrives. The platform distinguishes itself through it

Dramatiq is a distributed task queue and workload manager used to offload function execution to background workers. It functions as an asynchronous task orchestrator that enables the distribution of computational tasks across a cluster using a pluggable transport layer supporting RabbitMQ and Redis. The framework provides specialized tools for complex task orchestration, including the ability to link background jobs into sequences, pipelines, and barriers. It further manages distributed concurrency through the use of shared mutexes, rate limiters, and exponential backoff retries to prevent re

Hangfire is a background job scheduler and distributed task queue for .NET applications. It serves as a job orchestration framework that offloads heavy processing to background workers using a SQL-backed processor to manage job state across multiple servers. The framework distinguishes itself through reliable task scheduling, where job metadata and arguments are persisted in an external database to ensure tasks survive application restarts. It supports advanced orchestration patterns, including the ability to chain dependent tasks so that a child job triggers automatically upon the successful

Oban is a relational database-backed job processor and task scheduler for Elixir applications. It functions as a distributed workflow orchestrator that leverages database primitives to ensure job persistence, reliability, and consistent state management across clusters. The system distinguishes itself through complex workflow orchestration, enabling the composition of task dependencies using batching, sequential processing, and fan-out or fan-in patterns. It provides global throughput limiting and uniqueness enforcement to prevent duplicate work and protect downstream resources across distrib

.. image:: https://media.charlesleifer.com/blog/photos/huey3-logo.png

Good Job is a background job processor for Ruby on Rails that utilizes a PostgreSQL database as its primary storage engine. By leveraging relational database transactions, it ensures persistent and reliable task execution, integrating directly with the Active Job framework to handle asynchronous operations and recurring job scheduling within existing application environments. The system distinguishes itself through an in-process execution model that allows background workers to run within the same process as the web server, simplifying deployment by removing the need for separate worker servi

Ofelia is a recurring job scheduler designed to run commands inside Docker containers or directly on the host system using a defined timetable. It functions as a configuration engine that reads job schedules and commands from container labels, a concurrency guard to prevent overlapping task executions, and a log router for reporting job outcomes. The system distinguishes itself by using a label-based configuration model, allowing job schedules and execution logic to be defined within container metadata rather than external configuration files. It employs a lock-based concurrency control mecha

Coravel is a .NET application framework library providing a set of tools for task scheduling, background job queuing, event broadcasting, caching, and email delivery. It enables developers to implement recurring background jobs using Cron expressions and a fluent code-based syntax, removing the need for external system schedulers. The library features a mail delivery system that uses mailable classes to compose, preview, and queue emails through various delivery drivers. It includes an event broadcaster to decouple application components by triggering events and managing multiple listeners, a