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
piscinajs avatar

piscinajs/piscina

0
View on GitHub↗
5,053 stars·156 forks·TypeScript·other·17 viewspiscinajs.dev↗

Piscina

Piscina is a Node.js worker thread pool that runs CPU-intensive JavaScript functions across multiple threads for parallel execution. It manages a dynamic pool of worker threads with configurable size, handling task submission, cancellation, and lifecycle management through a promise-based interface.

The pool supports AbortController-based task cancellation, enabling clean termination of submitted or running tasks without disrupting other work. It enforces per-worker memory limits through V8 resource caps and applies backpressure with a configurable maximum queue size that emits a drain event when capacity becomes available. Piscina allows pluggable queue ordering to replace the default FIFO behavior with custom priority or deadline logic, and supports pluggable load balancing algorithms for assigning tasks to workers. Transferable objects like binary buffers can be passed between threads with zero-copy messaging, reducing memory overhead during data transfer.

Additional capabilities include deferred worker readiness through an asynchronous initialization protocol, performance monitoring with run-time and wait-time histograms, thread priority control on Linux, and the ability to customize worker environment setup with native addon loading. Piscina exposes a straightforward API for submitting functions to workers and retrieving results, with documentation and install instructions available through its npm package.

Features

  • Local Worker Pools - Provides a configurable thread pool for parallel execution of CPU-intensive JavaScript functions.
  • AbortController-Based Cancellations - Ships AbortController-based cancellation that cleanly terminates tasks without disrupting other workers.
  • Custom Parallel Task Execution - Runs CPU-intensive tasks concurrently across multiple threads to improve throughput.
  • Task Lifecycle Management - Manages the full lifecycle of tasks from submission through cancellation and completion in a worker pool.
  • Worker Pool Management - Manages a dynamic pool of worker threads with configurable size for balancing throughput and resource usage.
  • Inter-Thread Data Transfers - Supports zero-copy transfer of binary buffers and transferable objects between worker threads.
  • Node.js Worker Thread Pools - Provides a Node.js worker thread pool for parallel execution of CPU-intensive JavaScript functions.
  • Task Execution Engines - Runs user-defined functions on worker threads with configurable pool sizes and custom queues.
  • Parallel Task Executors - Executes user-defined functions on separate worker threads with promise-based results.
  • Inter-Thread Communication - Provides zero-copy transfer of binary buffers between worker threads and the main process.
  • Backpressure Controllers - Limits queued tasks with a configurable maximum size and emits a drain event when capacity becomes available.
  • Backpressure Queues - Implements configurable queue size limits with a drain event for backpressure control.
  • Pluggable Ordering - Supports pluggable queue ordering to replace default FIFO with custom priority or deadline logic.
  • Worker Initialization Scripts - Provides a deferred worker readiness protocol that runs initialization tasks before accepting new work.
  • Custom Load Balancers - Allows replacing the built-in load balancing algorithm with a custom strategy for assigning tasks to workers.
  • Resource Limit Enforcements - Enforces per-worker heap memory limits using V8 resource caps to prevent memory exhaustion.
  • V8 Resource Caps - Enforces per-worker memory limits through V8 resource caps to prevent memory exhaustion.
  • Remote Task Cancellation - Supports abort-signal-based cancellation of submitted or running tasks in the worker pool.

Star history

Star history chart for piscinajs/piscinaStar history chart for piscinajs/piscina

How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

AI search

Explore more awesome repositories

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

Start searching with AI

Projects sharing features with Piscina

These projects share indexed features with Piscina. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
  • dask/daskdask avatar

    dask/dask

    13,746View on GitHub↗

    Dask is a parallel computing framework and distributed task scheduler designed to scale Python data science workflows from single machines to large clusters. It functions as a cluster resource manager that orchestrates computational logic by representing tasks and their dependencies as directed acyclic graphs. This architecture allows the system to automate the distribution of workloads across available hardware while managing complex execution requirements. The project distinguishes itself through a lazy evaluation engine that defers data operations until they are explicitly requested, enabl

    Pythondasknumpypandas
    View on GitHub↗13,746
  • hatchet-dev/hatchethatchet-dev avatar

    hatchet-dev/hatchet

    6,622View 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↗6,622
  • 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
  • flyteorg/flyteflyteorg avatar

    flyteorg/flyte

    7,095View on GitHub↗

    Flyte is a Kubernetes-based machine learning orchestrator and containerized pipeline manager designed for coordinating AI workflows and data pipelines. It functions as an engine for defining and executing resilient pipelines, utilizing a data lineage tracker to maintain immutable execution states and ensure reproducible outputs. The platform distinguishes itself by packaging individual tasks into separate containers to ensure dependency isolation and environment consistency. It provides specialized capabilities for machine learning, including the transformation of trained models into scalable

    Go
    View on GitHub↗7,095
Compare all 30 related projects→

Frequently asked questions

What does piscinajs/piscina do?

Piscina is a Node.js worker thread pool that runs CPU-intensive JavaScript functions across multiple threads for parallel execution. It manages a dynamic pool of worker threads with configurable size, handling task submission, cancellation, and lifecycle management through a promise-based interface.

What are the main features of piscinajs/piscina?

The main features of piscinajs/piscina are: Local Worker Pools, AbortController-Based Cancellations, Custom Parallel Task Execution, Task Lifecycle Management, Worker Pool Management, Inter-Thread Data Transfers, Node.js Worker Thread Pools, Task Execution Engines.

Which projects share features with piscinajs/piscina?

Projects with overlapping indexed features include: dask/dask — Dask is a parallel computing framework and distributed task scheduler designed to scale Python data science workflows… hatchet-dev/hatchet — Hatchet is an open-source durable workflow engine and task orchestration platform. It provides a framework for… andywer/threads.js — threads.js is a JavaScript worker thread library and asynchronous task orchestrator designed to offload CPU-intensive… flyteorg/flyte — Flyte is a Kubernetes-based machine learning orchestrator and containerized pipeline manager designed for coordinating… prefecthq/prefect — Prefect is a workflow orchestration platform designed to define, schedule, and monitor complex data pipelines as… grpc/grpc — gRPC is a language-agnostic remote procedure call framework designed for high-performance communication between…