Threading

A clojure-inspired utility for threading arbitrary data into the first or last argument of a sequence of functions

Perform async work synchronously in Node.js using `worker_threads` with first-class TypeScript support.

A streaming way to send data to a Node.js Worker Thread

A minimal and tiny Node.js Worker Thread Pool implementation, a fork of piscina, but with fewer features

A fast, efficient Node.js Worker Thread Pool implementation

Use Rollup with workers and ES6 modules today.

Fast and powerful CSV parser for the browser that supports web workers and streaming large files. Converts CSV to JSON and JSON to CSV.

Thread-safe Helmet for React 16+ and friends

CLS using AsynWrap instead of async-listener - Node >= 4.7.0

WASI threads proposal implementation in JavaScript

Advanced, lightweight system and OS information library

Runs the following loaders in a worker pool

userland implementation of https://github.com/joyent/node/issues/5243

Consistent Web Workers in browser and Node.

A nodejs module for local and remote Inter Process Communication (IPC), Neural Networking, and able to facilitate machine learning.

A nodejs module for local and remote Inter Process Communication (IPC), Neural Networking, and able to facilitate machine learning.

Consistent Web Workers in browser and Node.

Relocate resource intensive third-party scripts off of the main thread and into a web worker.

React Native fork of thread-safe Helmet for React 16+ and friends

Make bluebird work with the continuation-local-storage module.

Utilities for running tasks on worker threads

Get CPU usage per thread

An Undici interceptor that routes requests over a worker thread

Inter-Thread Communication (ITC) is a library for managing communication between threads in a multi-threaded application.

Webpack plugin to bundle Workers automagically.

A resilience and transient-fault-handling library that allows developers to express policies such as Backoff, Retry, Circuit Breaker, Timeout, Bulkhead Isolation, and Fallback in a fluent and thread-safe manner. Inspired by .NET Polly.

Web workers & worker threads as simple as a function call

Stream variables beetween 2 JavaScript threads (client/server, ipc, worker/main thread).

Cooperative multi-tasking for Javascript

The fastest in-browser CSV (or delimited text) parser for React. It is full of useful features such as CSVReader, CSVDownloader, readString, jsonToCSV, readRemoteFile, ... etc.

Run sync/async function across Worker Threads

Nicer API for using worker-threads

Run a function with the possibility to interrupt it from another thread

A minimal and tiny Node.js Worker Thread Pool implementation, a fork of piscina, but with fewer features

FFmpeg WebAssembly version (single thread)

A simple Bus implementation for inter-thread communication.

Papa Parse wrapper for Angular. Fast parser-library for CSV to JSON and vice versa, with built in support for background-workers.

Full featured Promises/A+ implementation with exceptionally good performance

Utilities for running tasks on worker threads

Fast and small Node.js Worker_Threads and Cluster Worker Pool

Automatically move a module into a Web Worker (Webpack loader)

A simple isomorphic library for executing functions inside WebWorkers or Node Threads pools.

The best job scheduler for Node.js and JavaScript with cron, dates, ms, later, and human-friendly support. Works in Node v12.17.0+, uses worker threads to spawn sandboxed processes, and supports async/await, retries, throttling, concurrency, and cancelab

Simple worker threads pool using Node's worker_threads module. Compatible with ES6+ Promise, Async/Await.

An implementation to speed up the nodejs `dns.lookup` method by avoiding thread pool and using resolve4/resolve6 with DNS TTL values

requestAnimationFrame pool to avoid busyness on the thread

TypeScript-STL (Standard Template Library, migrated from C++)

Run gulp tasks in separate cpu processes

Tracks outstanding operations for a logical thread of execution

JavaScript library that provides pseudo-threading for leveraging resources during long, CPU intensive operations