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 rvagg/node-worker-farm

Projects sharing features with Node Worker Farm

30 open-source projects similar to rvagg/node-worker-farm, 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.

  • chyingp/nodejs-learning-guidechyingp avatar

    chyingp/nodejs-learning-guide

    6,865View on GitHub↗

    This project is a learning guide and collection of study notes designed to teach Node.js backend development. It provides a comprehensive core API reference and practical demonstrations for implementing server-side logic, network programming, and system APIs. The guide specifically covers advanced technical domains including process management for scaling applications via clusters and child processes, as well as network programming for building TCP, UDP, and HTTP services. It also includes detailed instructional material on security implementation, focusing on cryptographic hashing and encryp

    Rubycryptoexpressnodejs
    View on GitHub↗6,865
  • 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
  • ankane/strong_migrationsankane avatar

    ankane/strong_migrations

    4,411View on GitHub↗

    Strong Migrations is a PostgreSQL migration safety tool designed to prevent production downtime by detecting and blocking risky schema changes. It serves as a schema validator that identifies dangerous database operations and suggests safe alternatives to ensure zero-downtime deployments. The project distinguishes itself by acting as a database lock manager and index optimizer. It manages statement timeouts and implements automatic retry logic for lock timeouts to prevent database congestion. Additionally, it provides utilities to clean up invalid concurrent indexes and update table statistic

    Ruby
    View on GitHub↗4,411

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
  • richardknop/machineryRichardKnop avatar

    RichardKnop/machinery

    7,956View on GitHub↗

    Machinery is a distributed task queue and asynchronous workflow engine. It provides a system for processing heavy workloads outside the main request flow using a network of distributed background workers and a message-based job orchestrator. The project manages complex task lifecycles through sequential chaining, where results are passed between tasks, and parallel coordination, which can trigger callback tasks upon the completion of a group. It supports periodic workflow scheduling for recurring jobs and delayed execution via specific timestamps. The system includes capabilities for result

    Goamqpaws-sqsgo
    View on GitHub↗7,956
  • bee-queue/bee-queuebee-queue avatar

    bee-queue/bee-queue

    4,039View on GitHub↗

    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,

    JavaScriptbee-queuejob-queuejob-scheduler
    View on GitHub↗4,039
  • grosser/parallelgrosser avatar

    grosser/parallel

    4,261View on GitHub↗

    Parallel is a Ruby library and multi-process execution framework designed to accelerate CPU-intensive operations. It functions as a parallel job orchestrator and concurrent task runner that enables the execution of code across multiple processes or threads. The project distinguishes itself through secure inter-process communication, utilizing signed data serialization to prevent the injection of forged payloads between parent and child processes. It further differentiates its worker management by assigning unique identifiers to individual processes to prevent collisions when accessing shared

    Ruby
    View on GitHub↗4,261
  • 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
  • optimalbits/bullOptimalBits avatar

    OptimalBits/bull

    16,243View on GitHub↗

    Bull is a Node.js library for managing distributed jobs and message queues using Redis as the primary data store. It functions as a distributed task worker, job scheduler, and priority queue manager designed to handle asynchronous workloads across multiple processes. The project distinguishes itself by providing a persistent communication channel that decouples servers through the exchange of serializable data objects. It ensures distributed system reliability by detecting stalled tasks and recovering from process crashes to ensure every queued job is completed. The system covers a broad ran

    JavaScriptjobjob-queuemessage
    View on GitHub↗16,243
  • 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
  • yiisoft/yii2-queueyiisoft avatar

    yiisoft/yii2-queue

    1,065View on GitHub↗

    This project is a PHP framework for offloading time-consuming tasks to background workers, enabling asynchronous processing to keep the main application request cycle responsive. It provides a unified interface for managing background job queues, allowing developers to decouple application logic from specific storage backends and message brokers. The system distinguishes itself through a driver-based abstraction layer that supports diverse infrastructure, including relational databases, Redis, and RabbitMQ. It manages the full lifecycle of background tasks, offering capabilities for delayed s

    PHPamqpasyncbeanstalk
    View on GitHub↗1,065
  • ocramius/proxymanagerOcramius avatar

    Ocramius/ProxyManager

    4,939View on GitHub↗

    ProxyManager is a JavaScript proxy wrapper library and object-oriented utility for intercepting and modifying object behavior. It functions as an object behavior interceptor that wraps target objects to monitor, restrict, or modify method calls and property access at runtime. The library provides mechanisms for lazy initialization and lazy loading, deferring the creation of resource-heavy objects until a property or method is first accessed to reduce memory overhead. It uses an object-oriented structure to manage these proxy wrappers and their associated target objects. The tool covers capab

    PHP
    View on GitHub↗4,939
  • cglib/cglibcglib avatar

    cglib/cglib

    4,882View on GitHub↗

    cglib is a suite of tools for JVM bytecode generation, class transformation, and dynamic proxying. It provides a high-level API for creating and transforming Java bytecode at runtime to modify class behavior and a framework for intercepting method calls and field access. The project implements dynamic proxy generation to support aspect oriented programming and custom data access patterns. It also includes a serialization manager to implement serialization contracts by adding specific methods and controlling object replacement within proxy classes. The library covers bytecode manipulation and

    Java
    View on GitHub↗4,882
  • piscinajs/piscinapiscinajs avatar

    piscinajs/piscina

    5,235View on GitHub↗

    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

    TypeScriptmultithreadingnearform-researchnodejs
    View on GitHub↗5,235
  • unitech/pm2Unitech avatar

    Unitech/pm2

    43,323View on GitHub↗

    This project is a Node.js process manager, runtime environment, and production deployment orchestrator. It provides the foundational system components required to run, monitor, and restart applications in the background to ensure continuous service availability. The system distinguishes itself through a built-in load balancer that distributes network traffic across multiple process instances to utilize all available CPU cores. It includes a real-time process monitor with a terminal-based dashboard for tracking server health, CPU and memory usage, and aggregated logs. The tool covers a broad

    JavaScriptcommand-linecommand-line-tooldeploy
    View on GitHub↗43,323
  • powermock/powermockpowermock avatar

    powermock/powermock

    4,174View on GitHub↗

    Powermock is a Java mocking framework and unit testing tool that uses bytecode manipulation to mock static methods, final classes, and private constructors. It includes a Java agent instrumentation tool and a reflection-based testing utility to bypass encapsulation and modify class behavior at runtime. The project distinguishes itself by providing the ability to intercept the instantiation of objects via the new keyword and simulate the behavior of core Java system classes and native methods. It can override final modifiers on classes and methods and bypass signature restrictions for classes

    Java
    View on GitHub↗4,174
  • derekyrc/mini-springDerekYRC avatar

    DerekYRC/mini-spring

    6,360View on GitHub↗

    mini-spring is a Java dependency injection framework and inversion of control container. It manages the full lifecycle of beans, including instantiation, property population, and scope management, while providing a system for automating the wiring of components. The project implements a Java AOP framework that uses dynamic proxies to intercept method calls for cross-cutting logic. It also functions as a Java component scanner to automatically discover and register managed objects via annotations and as a Java event bus to decouple components through a publish-subscribe multicast system. The

    Javamini-springspringspring-boot
    View on GitHub↗6,360
  • btraceio/btracebtraceio avatar

    btraceio/btrace

    5,997View on GitHub↗

    btrace is a JVM dynamic tracing tool and performance profiler used for injecting safe instrumentation scripts into a running Java Virtual Machine without requiring a process restart. It functions as a Java agent framework and a Model Context Protocol server, exposing JVM diagnostic operations and tracing tools to large language models and AI assistants. The project distinguishes itself by enabling real-time code injection and bytecode-level instrumentation via a secure binary protocol. It ensures production stability through a static safety analysis engine that blocks unstable code patterns,

    Javabtracejavajava-application
    View on GitHub↗5,997
  • petruisfan/node-supervisorpetruisfan avatar

    petruisfan/node-supervisor

    3,728View on GitHub↗

    node-supervisor is a process supervisor and manager for Node.js applications. It provides automated lifecycle management and crash recovery by executing programs and monitoring their status to ensure continuous availability. The utility implements a hot-reloading workflow by monitoring the filesystem for source code modifications. When changes are detected, the supervisor terminates the existing process and triggers an immediate restart to apply updates. The tool covers process control capabilities including the spawning of external executables, signal-based termination, and the piping of st

    JavaScript
    View on GitHub↗3,728
  • phpspec/prophecyphpspec avatar

    phpspec/prophecy

    8,461View on GitHub↗

    Prophecy is a PHP mocking framework and test double library used to simulate object dependencies during unit testing. It serves as a behavioral testing tool for creating mocks, stubs, and dummies to isolate code and ensure predictable test results. The framework enables interaction verification by tracking method call counts and arguments to validate that specific interactions occurred. It supports defining specific return values or custom logic for method calls to simulate various execution scenarios. The library provides capabilities for argument matching based on type or value, interactio

    PHP
    View on GitHub↗8,461
  • rovo89/xposedbridgerovo89 avatar

    rovo89/XposedBridge

    4,067View on GitHub↗

    XposedBridge is an Android Java hooking framework and bytecode instrumentation engine. It functions as a runtime system for intercepting and modifying Java method calls within the Android operating system and installed applications. The project provides a mechanism for zygote process injection, ensuring that all spawned applications inherit the instrumentation logic. It enables the modification of internal Android system behaviors through method proxying and Java reflection to access private internal system members. The framework supports dynamic Android instrumentation and runtime analysis,

    JavaScriptandroidxposed
    View on GitHub↗4,067
  • steipete/aspectssteipete avatar

    steipete/Aspects

    8,436View on GitHub↗

    Aspects is an aspect-oriented programming library and method hooking framework designed for intercepting and modifying JavaScript function behavior without altering the original source code. It serves as a runtime logic injector that allows for the addition and removal of executable code wrappers from active functions. The library enables the injection of custom logic before or after methods to change application behavior at runtime. It further provides the ability to intercept method calls to capture or override return values before they reach the caller. The framework manages these interce

    Objective-Caspectshooksobjective-c
    View on GitHub↗8,436
  • moq/moq4Moq avatar

    Moq/moq4

    6,387View on GitHub↗

    Moq4 is a .NET mocking framework used to create simulated implementations of interfaces and abstract classes. It serves as a test double generator and behavior verification tool, allowing developers to isolate code during unit testing by replacing real dependencies with programmed mocks. The framework enables the definition of expected method behaviors and return values to control the execution flow of tests. It provides specialized capabilities for simulating methods that use output or reference parameters and mechanisms to monitor and trigger events on simulated objects. The library includ

    C#
    View on GitHub↗6,387
  • krakenjs/kraken-jskrakenjs avatar

    krakenjs/kraken-js

    4,911View on GitHub↗

    Kraken-js is a configuration-driven server manager and application framework for bootstrapping Node.js web applications. It provides a system for defining server behavior, middleware chains, and environment settings through JSON files rather than manual code. The framework focuses on separating application logic from infrastructure setup by resolving and injecting middleware into the request chain based on external configuration. It utilizes environment-based configuration merging to override baseline settings with context-specific values during startup. The system covers server security thr

    JavaScriptexpressjsjavascriptkrakenjs
    View on GitHub↗4,911
  • code4craft/tiny-springcode4craft avatar

    code4craft/tiny-spring

    4,071View on GitHub↗

    tiny-spring is a Java inversion of control container and aspect-oriented programming framework. It provides a system for managing object lifecycles and dependency injection to decouple application components. The project features a bytecode proxy generator that enables method interception and behavioral modification for classes that do not implement interfaces. It uses pointcut expressions to match specific classes and methods for the execution of cross-cutting logic via dynamic proxies. The framework manages singleton components and resolves object dependencies using lazy initialization. Ap

    Java
    View on GitHub↗4,071
  • mockito/mockitomockito avatar

    mockito/mockito

    15,432View on GitHub↗

    Mockito is a Java mocking framework and JUnit testing library used to create simulated objects and stub method calls to isolate components during unit tests. It functions as a dynamic proxy generator and bytecode instrumentation tool, allowing for the creation of runtime substitutes that mimic the behavior of real classes. The framework distinguishes itself by providing the ability to mock final classes and methods, bypassing standard language restrictions through bytecode modification. This capability enables the testing of legacy code that lacks interfaces. The toolset covers behavioral mo

    Java
    View on GitHub↗15,432
  • fuzhengwei/small-springfuzhengwei avatar

    fuzhengwei/small-spring

    4,899View on GitHub↗

    Small-Spring is a simplified Java implementation of the Spring framework designed to study the internal architecture of inversion of control containers and dependency injection frameworks. It functions as a bean container that manages object lifecycles and resolves dependencies through automated instantiation and property injection. The project implements a mechanism for intercepting method calls using dynamic proxies to support aspect-oriented programming. It separates cross-cutting concerns from business logic by wrapping target objects to modify method executions. The system covers compon

    Java
    View on GitHub↗4,899
  • open-cli-tools/concurrentlyopen-cli-tools avatar

    open-cli-tools/concurrently

    7,677View on GitHub↗

    Concurrently is a Node.js process manager and concurrent process runner designed to execute multiple shell commands simultaneously within a single terminal session. It provides core primitives for managing the lifecycles of child processes, coordinating parallel tasks, and establishing communication bridges to exchange data between parent and child processes. The tool features an ANSI terminal output formatter that styles process logs using custom prefixes, timestamps, and colors to differentiate between multiple output streams. It includes utilities for detecting terminal color depth and con

    TypeScriptclicommand-lineconcurrently
    View on GitHub↗7,677
  • java-native-access/jnajava-native-access avatar

    java-native-access/jna

    8,935View on GitHub↗

    JNA is a foreign function interface and native memory mapper that allows Java applications to call functions in shared native libraries without writing custom JNI wrapper code. It serves as a JNI alternative framework for invoking C functions and mapping native data structures using high-level interfaces. The library distinguishes itself through its ability to translate Java objects and primitives into C-style structs, unions, and pointers for cross-platform memory exchange. On Windows, it provides a dedicated toolkit for interacting with Component Object Model objects using both early and la

    Java
    View on GitHub↗8,935
  • 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
  • jboss-javassist/javassistjboss-javassist avatar

    jboss-javassist/javassist

    4,231View on GitHub↗

    Javassist is a bytecode engineering toolkit for analyzing, modifying, and generating Java bytecode and class files. It functions as a bytecode manipulation library that allows for the editing of class files through either direct bytecode access or high-level source code syntax. The project provides specialized tools for the programmatic creation of new Java classes and interfaces during runtime. It includes a dynamic proxy generator for intercepting method calls and a class loader interceptor that automatically modifies class definitions as they are loaded into the Java Virtual Machine. Addi

    Javajavajava-bytecode
    View on GitHub↗4,231