Open-source alternatives to Tunny

p-queue is a JavaScript promise queue and concurrent task scheduler designed to limit the number of active asynchronous operations. It serves as an asynchronous rate limiter and promise lifecycle manager to prevent resource exhaustion. The project distinguishes itself through priority-based task scheduling and token-bucket rate limiting to control execution frequency. It integrates with abort signals for task cancellation and provides mechanisms to pause, resume, and clear pending operations. The tool covers broader traffic management capabilities including operation timeouts and concurrency

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

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

Radash is a TypeScript functional utility library designed for data transformation, validation, and workflow management. It provides a collection of typed helper functions to manipulate arrays, objects, and strings. The project features an asynchronous workflow toolkit for managing promises, retries, and concurrency limits, alongside a suite of boolean validators for verifying primitive types, objects, and promises. It also implements functional programming patterns such as function composition, partial application, and error-first response patterns. The library covers a broad surface of cap

RxGo is a functional reactive programming library and an implementation of ReactiveX for the Go language. It serves as an asynchronous stream processing toolkit designed to coordinate event-based programs and data flows using the observable pattern. The library enables the construction of asynchronous processing pipelines that transform, filter, and combine event sequences. It distinguishes itself through the use of functional operators to compose these pipelines and provides mechanisms for managing concurrent execution. The toolkit covers a broad range of stream orchestration capabilities,

CyclicBarrier golang implementation

A sync.WaitGroup with error handling and concurrency control

A concurrent toolkit to help execute funcs concurrently in an efficient and safe way. It supports specifying the overall timeout to avoid blocking.

🚦 Semaphore pattern implementation with timeout of lock/unlock operations.

Make functions return a channel for parallel processing via go routines.

Fast resizable golang semaphore primitive

Run functions in parallel :comet:

Unlimited job queue for go, using a pool of concurrent workers processing the job queue entries

Structured Concurrency in Go

Library to manage application lifetime in a Go microservice architecture

A collection of tools for Golang

Zero-config, auto-scaling worker pool for Go with priority-aware scheduling, adaptive resource management, and per-task retry logic.

Go toolkit for clean, composable, channel-based concurrency

🐝 A Highly Performant and easy to use goroutine pool for Go

Lightweight Goroutine pool

Simply way to control goroutines execution order based on dependencies

Hands is a process controller used to control the execution and return strategies of multiple goroutines.

A pool that spins up a given number of processes in advance and attaches stdin and stdout when needed. Very similar to FastCGI but works for any command.

🚧 Flexible mechanism to make execution flow interruptible.

Solution for accumulation of events and their subsequent processing.

goworker is a Go-based background worker that runs 10 to 100,000* times faster than Ruby-based workers.