Open-source alternatives to Yii2 Queue

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,

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

BullMQ is a Redis-backed message queue library and background processor designed for distributed task queueing. It functions as a distributed queue manager and task scheduler, utilizing Redis to manage asynchronous job processing and persistence. The system distinguishes itself through its role as a job workflow orchestrator, enabling the definition of complex parent-child job dependencies and hierarchies for multi-step workflows. It provides sandboxed process execution to isolate heavy workloads and prevent event loop blocking, alongside distributed rate limiting to protect downstream servic

rq is a distributed task queue and background worker system for Python that uses a Redis backend to decouple task submission from execution. It functions as a reliable message queue and task scheduler, allowing Python functions or asyncio coroutines to be processed asynchronously across multiple worker processes. The project distinguishes itself through reliable queuing mechanisms that prevent job loss during worker crashes using atomic operations. It provides specialized orchestration capabilities, including the prevention of duplicate jobs, job execution prioritization, and the ability to m

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

Horizon is a background job orchestrator and worker manager for Redis queues. It provides a monitoring dashboard to track job throughput, wait times, and failure rates, alongside a system for managing job retries, execution timeouts, and worker distribution. The project distinguishes itself through a Redis-backed monitoring interface that identifies system bottlenecks and a queue alerting system that sends notifications when background job wait times exceed defined thresholds. Worker processes are managed via version-controlled configuration files to ensure consistent balancing and scaling ac

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

TastyIgniter is a comprehensive restaurant management system and digital ordering engine. Built as a modular application framework, it provides the tools necessary to operate online food ordering, table reservation systems, and multi-vendor e-commerce platforms. The platform is designed to handle complex restaurant operations, including multi-location networking and multi-vendor marketplace management. It distinguishes itself through specialized restaurant automation, such as coordinating guest limits and time slots for bookings, managing ingredient and allergen catalogs, and implementing mul

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

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

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

ServiceStack is a high-performance .NET web framework designed for building type-safe APIs using strongly-typed request and response objects. It functions as a message-based API engine that decouples business logic from the transport layer, allowing services to be exposed via multiple protocols including HTTP, gRPC, and various message queue providers. The framework is distinguished by its type-safe API generator, which produces native client SDKs and data transfer objects from service metadata across multiple languages. It also includes a distributed service gateway for microservices orchest

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

Bacon is a background job runner and text-based user interface test dashboard designed for tracking code health and isolating failing tests. It functions as a developer workflow automator and file system watcher that triggers shell commands and verification tasks automatically when source files are modified. The tool allows for the definition of custom checkers and keyboard shortcuts to accelerate the iteration and debugging process. It provides a focused display for monitoring project health by tracking compilation errors and restricting active jobs to only those tests that have failed. The

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

Redash is a self-hosted analytics platform and SQL data visualization tool. It provides a web-based SQL query editor for writing, executing, and scheduling database queries, and functions as a business intelligence dashboard for monitoring metrics via visual widgets. The platform distinguishes itself through its data source connectors, which integrate with various SQL, NoSQL, and API-based stores to retrieve information for analysis. It enables self-service analytics by allowing users to run queries with dynamic parameters and supports shared data reporting via public links or embedded dashbo

Queue Classic is a background processing framework for Ruby applications that manages asynchronous tasks by utilizing relational database tables for job persistence. By storing tasks directly within the database, the system ensures that job creation remains coupled with application transactions, guaranteeing that tasks are only queued when associated data changes are successfully committed. The framework coordinates concurrent worker processes through database-level locking mechanisms, which prevent redundant execution and allow for distributed task processing without the need for an external

Node-worker-farm is a framework for distributing intensive computational tasks across a managed pool of background processes. By offloading heavy operations to independent child processes, it enables concurrent execution and prevents the main event loop from becoming blocked, allowing applications to maximize CPU utilization across available processor cores. The library distinguishes itself through a proxy-based interface that maps local function calls directly to exported methods within remote worker modules. This abstraction simplifies the distribution of work by treating background tasks a

This project is a reference library of architectural blueprints, study materials, and design patterns for building scalable, high-availability distributed systems. It serves as a technical guide for scalability engineering, providing structural solutions for common engineering challenges. The repository focuses on distributed systems design, covering essential patterns for data replication, consensus algorithms, and transaction management. It distinguishes itself by offering detailed blueprints for specialized domains, including real-time data streaming, large-scale data storage, and high-ava

This repository serves as a comprehensive collection of practical demonstrations and tutorials for building enterprise-ready Java applications using the Spring Boot framework. It provides structured guidance on core development topics, including the implementation of inversion-of-control containers, auto-configuration mechanisms, and convention-over-configuration patterns to simplify the assembly of complex systems. The project distinguishes itself by offering implementation patterns for diverse architectural requirements, such as microservices development, reactive programming models for hig

node-schedule is a job scheduler for Node.js that executes arbitrary functions based on specific dates or recurring rules. It functions as a date-based and event-driven scheduling system for JavaScript environments, allowing for the automation of one-off events and periodic tasks. The project supports recurring job scheduling through cron-style strings and recurrence rules, as well as the ability to schedule tasks for precise, single execution dates. It includes timezone-aware date calculations to map recurring rules against global or local time offsets. The system provides a comprehensive j

Beanstalkd is a distributed work queue server designed for asynchronous job processing. It functions as a standalone server that distributes background tasks between producers and consumers to improve application responsiveness and throughput. The system organizes tasks using numeric priority levels to ensure critical work is processed first. It manages the job lifecycle through discrete states and uses a simple line-based text protocol over TCP for communication. To ensure reliability, the server persists job data to a sequential disk log, allowing the queue state to be recovered after a sy

ZenML is an extensible machine learning orchestration framework designed to manage the end-to-end lifecycle of data pipelines and AI agent workflows. It functions as a durable orchestrator that executes machine learning tasks as directed acyclic graphs, ensuring that every step is containerized for consistent performance across local, cloud, and hybrid infrastructure. By decoupling pipeline code from underlying compute and storage backends, the platform allows developers to define infrastructure-agnostic stacks that remain portable across diverse environments. The project distinguishes itself

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,

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

Quarkus is a Kubernetes-native Java framework designed for building high-performance, memory-efficient applications. It utilizes ahead-of-time native compilation to transform Java code into standalone, optimized binaries that eliminate the need for a virtual machine, enabling rapid startup and reduced memory consumption. By performing code augmentation during the build phase, it shifts heavy processing tasks away from runtime, ensuring that applications are optimized for cloud-native environments. The framework distinguishes itself through a unified approach to reactive and imperative program

Store.js is a client-side state persistence library and web storage abstraction layer. It provides a consistent browser key-value storage wrapper that manages the persistence of application state across sessions using the most capable available local storage mechanism. The engine is extensible, allowing for the integration of custom storage backends and plugins to modify how data is read and written. It functions as a reactive web storage manager, monitoring specific keys to trigger notifications when stored values are updated. The library handles automatic data serialization for complex typ