awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
Back to sindresorhus/p-queue

Projects sharing features with P Queue

30 open-source projects similar to sindresorhus/p-queue, ranked by shared indexed features. Tags may describe platforms or build tools rather than the same primary purpose. Check each project’s use case, license, and deployment requirements before treating it as a replacement.

  • jhalterman/failsafejhalterman avatar

    jhalterman/failsafe

    4,307View on GitHub↗

    Failsafe is a JVM resilience library providing a collection of fault tolerance patterns for Java applications. It functions as an asynchronous execution wrapper that runs tasks in the background and returns futures to prevent thread blocking. The library allows for the composition of resilience policies, enabling multiple patterns to be stacked into a sequential pipeline. It includes specific implementations for circuit breaking to prevent system overload, rate limiting to control traffic flow, and a framework for managing retries and fallbacks. Capability areas cover traffic management thro

    Java
    View on GitHub↗4,307
  • taskforcesh/bullmqtaskforcesh avatar

    taskforcesh/bullmq

    9,576View on GitHub↗

    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

    TypeScriptbackground-jobselixirnodejs
    View on GitHub↗9,576
  • ruby-concurrency/concurrent-rubyruby-concurrency avatar

    ruby-concurrency/concurrent-ruby

    5,836View on GitHub↗

    Concurrent Ruby is a comprehensive concurrency toolkit for the Ruby language that provides thread-safe data structures, synchronization primitives, and asynchronous execution patterns. It implements core concurrency abstractions including an actor model framework where isolated actors communicate through asynchronous message passing, a future and promise system for composing non-blocking operations, and thread pool executors that manage reusable worker threads for concurrent task execution. The library distinguishes itself through a broad set of coordination mechanisms that go beyond basic th

    Ruby
    View on GitHub↗5,836

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Find more with AI search
  • stephencleary/asyncexStephenCleary avatar

    StephenCleary/AsyncEx

    3,728View on GitHub↗

    AsyncEx is a .NET asynchronous synchronization library providing a collection of primitives to coordinate tasks and manage execution flow. It implements mechanisms for asynchronous resource locking, event signaling, and concurrency control to ensure correct execution order in environments supporting async/await. The library includes an asynchronous lock implementation to protect shared resources without blocking threads, an async semaphore controller to limit simultaneous operations, and an event signaling system to manage the startup and shutdown of asynchronous workflows. The toolkit cover

    C#asyncasync-awaitasyncex
    View on GitHub↗3,728
  • jeffail/tunnyJeffail avatar

    Jeffail/tunny

    4,022View on GitHub↗

    Tunny is a worker pool library and concurrency manager for Go. It functions as a concurrent task scheduler that limits the number of parallel workers processing jobs to prevent system resource exhaustion. The project enables the maintenance of persistent state within individual worker routines to avoid repeated initialization costs. It also supports dynamic worker scaling, allowing the number of active background workers to be adjusted in real time without interrupting tasks in progress. The library provides mechanisms for task timeout enforcement and worker lifecycle management, including t

    Gogogolanggoroutine-pool
    View on GitHub↗4,022
  • petkaantonov/bluebirdpetkaantonov avatar

    petkaantonov/bluebird

    20,515View on GitHub↗

    Bluebird is a JavaScript promise library designed for managing asynchronous operations with a custom promise implementation. It provides a framework for controlling promise lifecycles and orchestrating non-blocking programming patterns. The library distinguishes itself with an asynchronous debugging toolkit that captures long stack traces across asynchronous boundaries and a global handler for unhandled promise rejections. It includes a predicate-based error filtering system to target specific exception types and a mechanism for the deterministic cleanup of system resources. It covers a broa

    JavaScript
    View on GitHub↗20,515
  • bogdanp/dramatiqBogdanp avatar

    Bogdanp/dramatiq

    5,136View on GitHub↗

    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

    Pythondistributed-lockpythonrabbit
    View on GitHub↗5,136
  • gevent/geventgevent avatar

    gevent/gevent

    6,440View on GitHub↗

    Gevent is a Python coroutine concurrency library and asynchronous task manager designed for high-concurrency I/O tasks. It provides a cooperative networking framework for building asynchronous TCP, UDP, and HTTP servers, as well as a WSGI web server implementation for hosting web applications. The project is distinguished by its standard library monkey-patching tool, which replaces blocking synchronous functions with cooperative versions to enable asynchronous behavior in third-party code. This allows for a cooperative multitasking workflow where the system yields execution during I/O waits t

    Pythonasynciocoroutinesgreenlet
    View on GitHub↗6,440
  • inngest/inngestinngest avatar

    inngest/inngest

    6,021View on GitHub↗

    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

    Go
    View on GitHub↗6,021
  • apify/crawlee-pythonapify avatar

    apify/crawlee-python

    8,097View on GitHub↗

    Crawlee-python is a web crawling framework for building scalable scrapers using Python. It serves as a comprehensive tool for web scraping automation, providing a system to extract structured data from websites using both lightweight HTTP requests and headless browser automation. The framework is distinguished by its anti-bot evasion capabilities, which include browser fingerprint impersonation and tiered proxy rotation to bypass detection systems and solve challenges such as Cloudflare. It also incorporates artificial intelligence for autonomous website navigation and schema-based data extra

    Pythonapifyautomationbeautifulsoup
    View on GitHub↗8,097
  • sindresorhus/p-allsindresorhus avatar

    sindresorhus/p-all

    346View on GitHub↗

    Run promise-returning & async functions concurrently with optional limited concurrency

    TypeScript
    View on GitHub↗346
  • sindresorhus/p-limitsindresorhus avatar

    sindresorhus/p-limit

    2,887View on GitHub↗

    Run multiple promise-returning & async functions with limited concurrency

    JavaScript
    View on GitHub↗2,887
  • sindresorhus/p-mapsindresorhus avatar

    sindresorhus/p-map

    1,499View on GitHub↗

    Map over promises concurrently

    JavaScriptasyncasync-awaitasync-functions
    View on GitHub↗1,499
  • sindresorhus/delaysindresorhus avatar

    sindresorhus/delay

    626View on GitHub↗

    Delay a promise a specified amount of time

    JavaScript
    View on GitHub↗626
  • sindresorhus/p-timessindresorhus avatar

    sindresorhus/p-times

    42View on GitHub↗

    Run promise-returning & async functions a specific number of times concurrently

    JavaScript
    View on GitHub↗42
  • sindresorhus/pifysindresorhus avatar

    sindresorhus/pify

    1,507View on GitHub↗

    Promisify a callback-style function

    JavaScriptpromise-utilitiespromisespromisify
    View on GitHub↗1,507
  • sindresorhus/p-eventsindresorhus avatar

    sindresorhus/p-event

    450View on GitHub↗

    Promisify an event by waiting for it to be emitted

    JavaScript
    View on GitHub↗450
  • automattic/kueAutomattic avatar

    Automattic/kue

    9,437View on GitHub↗

    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

    JavaScriptjob-queuepriority-queueworker-queue
    View on GitHub↗9,437
  • futureverse/futurefutureverse avatar

    futureverse/future

    1,013View on GitHub↗

    Future is a unified framework for parallel and distributed computing in R that abstracts infrastructure complexity to enable asynchronous task execution. It provides a consistent interface for dispatching intensive computations to local multicore processors or remote clusters, allowing developers to manage background jobs without blocking the main session. The framework distinguishes itself through a strategy-based execution abstraction that decouples task definitions from the underlying compute backend. This allows for the seamless swapping of execution environments while maintaining global

    Rasynchronouscrandistributed-computing
    View on GitHub↗1,013
  • schedmd/slurmSchedMD avatar

    SchedMD/slurm

    4,503View on GitHub↗

    Slurm is a cluster workload manager and job scheduler designed for high-performance computing environments. It functions as a distributed compute orchestrator that queues and executes large-scale computational tasks across multiple compute nodes in a cluster. The system acts as a resource arbitrator, distributing hardware nodes and processors among concurrent users to prevent resource conflicts and maximize efficiency. It coordinates the simultaneous launch of multiple processes across different physical servers to execute parallel jobs and scientific workloads. The platform covers broad cap

    C
    View on GitHub↗4,503
  • angrave/systemprogrammingangrave avatar

    angrave/SystemProgramming

    5,734View on GitHub↗

    This is an open-source, crowd-sourced wiki textbook that teaches Linux system programming in C. It covers the core operating system concepts of process management through the fork-exec-wait model, dynamic memory allocation using implicit free list heap allocators, inode-based file systems, inter-process communication via pipes and shared memory, POSIX threads with synchronization primitives, signal-based asynchronous notification, virtual memory with page table translation, and runtime diagnostics using Valgrind and GDB. The textbook distinguishes itself by providing practical, implementation

    View on GitHub↗5,734
  • andywer/threads.jsandywer avatar

    andywer/threads.js

    3,526View on GitHub↗

    threads.js is a JavaScript worker thread library and asynchronous task orchestrator designed to offload CPU-intensive tasks to background threads. It functions as a cross-platform worker pool and a TypeScript worker runner that automatically transpiles and executes TypeScript files within separate threads. The project distinguishes itself by providing a unified worker API that allows for cross-platform execution across different JavaScript environments. It includes a specialized worker data serialization tool to pass complex class instances and binary data between threads, and supports inlini

    TypeScriptisomorphic-javascriptjavascriptmultithreading
    View on GitHub↗3,526
  • jrallison/go-workersjrallison avatar

    jrallison/go-workers

    1,383View on GitHub↗

    Go-workers is a background job processor for Go applications that coordinates asynchronous task execution using Redis queues. It implements the Sidekiq-compatible wire protocol and payload structures, allowing interoperability with existing background processing ecosystems and clients. The system manages task distribution through atomic list operations on a shared data store to guarantee reliable message delivery and prevent lost tasks during abrupt worker failures. It features configurable concurrency limits to control throughput per queue by dispatching incoming tasks across bounded synchr

    Go
    View on GitHub↗1,383
  • caolan/asynccaolan avatar

    caolan/async

    28,150View on GitHub↗

    Async is a JavaScript asynchronous flow library designed to manage the execution and coordination of asynchronous tasks in Node.js and the browser. It provides functional utilities to wrap, process, and orchestrate complex asynchronous workflows. The library distinguishes itself through a comprehensive task orchestrator that handles dependency graphs to resolve circular references and manages concurrent task queues. It includes a unification bridge that allows callback-style and promise-based functions to operate within the same execution interface. The project covers several primary capabil

    JavaScript
    View on GitHub↗28,150
  • hatchet-dev/hatchethatchet-dev avatar

    hatchet-dev/hatchet

    8,239View on GitHub↗

    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

    Goconcurrencydagdistributed
    View on GitHub↗8,239
  • panjf2000/antspanjf2000 avatar

    panjf2000/ants

    14,523View on GitHub↗

    Ants is a goroutine pool library for Go that functions as a concurrent task orchestrator and resource consumption limiter. Its primary purpose is to manage and reuse a pool of goroutines to limit concurrency and reduce the memory allocation overhead associated with frequent thread creation. The system provides a runtime worker manager capable of adjusting pool capacity dynamically to respond to fluctuating workloads. To maintain stability, it includes panic recovery mechanisms that intercept runtime failures within worker threads to prevent a single failing task from crashing the entire appli

    Goantsgogoroutine
    View on GitHub↗14,523
  • failsafe-lib/failsafefailsafe-lib avatar

    failsafe-lib/failsafe

    4,318View on GitHub↗

    Failsafe is a JVM fault tolerance library and resilience pattern framework. It provides a toolkit for implementing circuit breakers, rate limiters, and other stability patterns within Java Virtual Machine applications to prevent cascading failures in distributed systems. The project is distinguished by its policy-based execution pipeline, which allows for the composition of multiple resilience patterns into a sequential flow. It features a state-machine circuit breaker to manage service recovery and a leaky-bucket rate limiter to control operation frequency. The library covers a broad range

    Javabulkheadcircuit-breakerfallback
    View on GitHub↗4,318
  • geektutu/high-performance-gogeektutu avatar

    geektutu/high-performance-go

    3,887View on GitHub↗

    This project is a comprehensive performance programming guide and reference for the Go language, focusing on runtime efficiency and memory optimization. It provides a collection of patterns and techniques designed to increase execution speed by reducing garbage collection overhead and optimizing memory usage. The resource distinguishes itself through detailed reference implementations for memory optimization, such as escape analysis, object pooling, and structure memory alignment. It offers specific strategies for reducing binary size and improving CPU cache efficiency through structure memor

    Goeffective-golanggogolang
    View on GitHub↗3,887
  • nukesor/pueueNukesor avatar

    Nukesor/pueue

    6,054View on GitHub↗

    Pueue is a task queue manager for shell commands, built as a daemon and command-line interface. It accepts shell commands into a managed queue and executes them with configurable parallel execution limits, supporting both global and per-group concurrency controls. The daemon persists its entire state—task queue, logs, and configuration—to disk, ensuring survival across crashes and system restarts. The project distinguishes itself through a dependency graph that lets tasks declare prerequisites, forming a directed acyclic graph that controls execution order. Tasks can be organized into named g

    Rustcommand-linecommand-line-tooldaemon
    View on GitHub↗6,054
  • brianway/java-learningbrianway avatar

    brianway/java-learning

    4,285View on GitHub↗

    This project is an instructional repository and learning resource providing a comprehensive collection of study notes, programming guides, and runnable source code examples. It serves as a guide for Java SE and Java web development, featuring a library of code samples that demonstrate common algorithms and technical implementations. The repository focuses on language core and runtime analysis, with detailed tutorials on multithreading and concurrency. It provides practical implementations of software architecture and design patterns, such as the singleton and strategy patterns, as well as exp

    Javajava
    View on GitHub↗4,285