30 open-source projects similar to petruisfan/node-supervisor, 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.
Realize is a developer workflow orchestrator that monitors the filesystem for changes and automatically restarts applications, runs build scripts, and executes custom commands in response. It coordinates sequential command pipelines across setup, start, and cleanup phases, managing process lifecycles for multiple projects from a single declarative YAML configuration file. The tool distinguishes itself by combining file-change-triggered automation with multi-project process management, allowing several independent projects to be watched and coordinated concurrently. It supports environment var
Fresh is a development utility and process manager for Go web applications that synchronizes the running state of a binary with its source code. It functions as a live-reload orchestrator that automatically recompiles and restarts Go applications when source or template files are modified. The tool distinguishes itself by capturing compilation failures and serving them through a web middleware layer, allowing build errors to be displayed directly within the browser. It manages the full development cycle by monitoring the filesystem via kernel events to trigger automatic rebuilds and handling
CliWrap is an asynchronous process manager and child process wrapper library used to execute external commands and integrate command line interfaces into applications. It provides a framework for launching external programs using asynchronous patterns, managing child processes, and validating exit codes. The library distinguishes itself through its ability to route standard input, output, and error streams to memory buffers or real-time event streams. It enables real-time monitoring of process output lines and supports process termination via cancellation tokens. The project covers a broad r
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
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
Passenger is a multitenant web server and dynamic process manager designed to host and manage web applications written in Ruby, Python, and Node.js. It functions as an application server that handles process and resource management, ensuring that multiple independent applications can run on a single server instance. The project distinguishes itself through a flexible deployment model, capable of operating as a self-contained standalone web server or as an integration module for existing high-performance external web servers. It employs a language-agnostic interface to provide polyglot hosting
Tailspin is a regex-based text colorizer and terminal log viewer designed to transform plain text streams into colorized output. It functions as a command line log highlighter and tailer that applies syntax highlighting to logs using regular expressions. The tool distinguishes itself through its ability to monitor files in real time and pipe live output through a highlighter. It recognizes and colors common data types such as IP addresses, UUIDs, HTTP methods, JSON objects, dates, and memory pointers. Users can define custom highlight styles and regex patterns to assign specific colors to uni
Skim is an interactive text filter and terminal selection tool written in Rust. It functions as a command line interface utility that processes input streams to isolate specific entries through real-time user queries and sorting. The tool differentiates itself through ANSI compatibility, allowing it to parse color codes and maintain text formatting during the search process. It supports multiple matching strategies, including configurable fuzzy matching algorithms and regular expression integration. The application covers a broad range of capabilities including field-specific filtering, resu
This project is an AST-based code optimizer and compressor for modern ECMAScript, JSX, and TypeScript source code. It functions as a JavaScript minifier that uses the Babel toolchain to reduce file size by removing unnecessary characters and whitespace while preserving program logic. The tool is distinguished by its ability to process experimental language proposals and transform modern syntax into browser-compatible versions. It provides specialized handling for React JSX transpilation and strips type annotations from TypeScript files to produce compressed production assets. The system cove
Watchdog is a Python library and set of shell utilities for monitoring filesystem events. It provides a framework for tracking real-time changes to files and directories, mapping those events to configurable automation handlers, and executing system actions based on file creation, modification, or deletion. The project includes an event-driven shell utility for triggering custom scripts and commands automatically. It utilizes a configurable handler framework that allows users to associate specific filesystem events with specialized plugin logic defined in configuration files. The system moni
Watchman is a filesystem change monitor and recursive directory watcher that operates as a background service to track file modifications in real time. It functions as an event-driven file trigger and state query engine, allowing users to retrieve directory snapshots and lists of changed files since a previous check. The project provides tooling for incremental builds by identifying exactly which files have changed to compile only necessary project components. It is designed for large scale directory watching, monitoring massive file trees while executing external commands or scripts automati
Inotify-tools is a collection of command-line utilities that provide a direct interface to the Linux kernel inotify subsystem. It functions as a filesystem event monitor, allowing users to track modifications, creations, and deletions of files and directories in real time. The project translates low-level kernel event structures into human-readable text output, enabling the integration of filesystem monitoring into shell scripts and automated workflows. It manages multiple filesystem watches by tracking individual file descriptors and supports recursive directory traversal to ensure comprehen
This project is a technical study and analysis guide focused on the internal architecture of Node.js. It provides an in-depth examination of the runtime, focusing on how the engine manages memory handles, executes asynchronous operations, and implements core module logic. The guide specifically analyzes the integration of native C++ classes and functions into JavaScript and documents the behavior of the libuv event loop. It includes detailed references for optimizing performance by identifying V8 compiler bailouts and profiling execution to improve resource efficiency. The material covers a
entr is a command-line tool and shell command orchestrator that executes arbitrary terminal commands automatically whenever monitored files are modified. It serves as a Unix file system monitor that maps filesystem events to the execution of user-defined shell commands. The utility functions as a development workflow automator by restarting background processes and refreshing console output to provide immediate feedback during coding. It can terminate and restart long-running services when configuration or source code is updated. The project covers automated task execution and continuous int
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
This project is a command-line synchronization client for OneDrive and SharePoint libraries on Linux. It functions as a synchronization engine that aligns local filesystems with cloud storage through bidirectional, unidirectional, or download-only workflows. The client supports headless authentication for servers without web browsers and can be deployed as a background service or within a containerized environment. It enables the management of multiple distinct cloud accounts on a single system and integrates with shared SharePoint sites and document libraries. The synchronization engine inc
This is a cloud storage client and synchronization service for Linux that maintains data parity between local directories and OneDrive. It functions as both a command line interface and a background service to provide automated file backups and cloud synchronization. The tool supports multi-account management by isolating separate cloud profiles into distinct local directories through instance-based configuration. It utilizes delta-based data transfers and resumable chunked uploads to ensure large files are transmitted efficiently and can recover from interrupted transfers. The service provi
Neogit is a visual Git version control client designed for managing repositories through staging, committing, pushing, and merging. It provides a suite of tools for inspecting code differences, visualizing commit history via a graphical branch tree, and automating event-based workflows. The project features a workflow automation system that triggers custom logic and notifications based on repository events, such as branch creation or pushes. It also includes utilities for generating direct deep-links to commits, pull requests, and file structures on remote version control hosting providers.
Actix is a Rust actor framework and concurrent programming toolkit designed for building applications that manage state through an asynchronous messaging system. It provides a model where independent actors serve as autonomous units of state and logic, communicating via strongly typed messages sent to unique addresses. The framework distinguishes itself by isolating state within these actors, allowing internal data to be mutated safely during message handling without the use of locks or mutexes. It employs an asynchronous mailbox system to buffer incoming requests and uses supervision strateg
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
fsearch is a high-performance desktop file search tool and filesystem indexing engine. It provides near-instant location of files and folders on a local filesystem by utilizing a background indexing system that monitors filesystem changes in real time. The utility distinguishes itself through advanced query capabilities, including support for boolean search logic using AND, OR, and NOT operators, as well as regular expression and wildcard filtering. It allows for precise result refinement using literal character handling and specific search modifiers such as case sensitivity and exact matches
Lsyncd is an event-driven directory synchronization daemon that monitors local filesystem changes to mirror data to remote servers. It functions as a customizable sync orchestrator, watching for file creations, modifications, and deletions to trigger automated synchronization tasks or user-defined scripts. The tool specifically automates rsync workflows, utilizing secure shell connections to maintain consistent copies of local data on remote targets. It optimizes data transmission by performing remote file management, such as renames and deletions, via secure shells to avoid unnecessary re-tr
lsyncd is a synchronization service and background daemon that monitors local directories for changes and mirrors them to remote targets in real time. It operates as a sync manager that orchestrates the movement of local data to remote hosts, ensuring data consistency through automated mirroring. The project uses an embedded Lua scripting engine to define configuration logic, allowing for custom synchronization actions and layered rule definitions. It leverages rsync for delta-transfers to minimize bandwidth and utilizes SSH for secure encrypted communication with remote servers. The service
Ergo is a distributed actor framework for Go that implements the Erlang distribution protocol, enabling the construction of resilient, concurrent applications that can communicate transparently with Erlang/OTP nodes. At its core, it provides an actor model with isolated lightweight processes, priority-ordered mailboxes, and a meta-process architecture that separates blocking I/O from sequential message handling to prevent actor freezing. The framework includes a Raft-inspired cluster consensus system for leader election and automatic failover, along with OTP-style supervision trees that organi
llama-fs is an automated directory manager and file system organizer that uses large language models to categorize, rename, and sort files into structured directories. It functions as a local data pipeline that analyzes file content to determine appropriate folder hierarchies and naming patterns. The project emphasizes privacy by routing data processing to local model instances, ensuring sensitive file information remains on the device rather than being sent to cloud providers. It utilizes multimodal analysis to process images, audio, and text, allowing the system to identify and classify div
grv is a terminal-based version control client and interactive Git repository browser. It functions as a terminal user interface for browsing commit history, inspecting code differences, and managing branches and tags within Git repositories. The project distinguishes itself through a graphical commit graph visualizer that renders branching patterns and merge history directly in the terminal. It employs a tiled view layout engine and tabbed workspace management to display multiple repository perspectives simultaneously, supported by real-time filesystem monitoring to update the interface auto
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
Spotless is a multi-language formatting orchestrator and Gradle plugin that automates code styling across various programming languages within a single build pipeline. It functions as a coordinator for multiple third-party formatters, a code style linting tool, and a system for inserting and updating standardized license headers. The project distinguishes itself through git-integrated style enforcement, using pre-push hooks and git references to apply formatting only to modified files or lines. It supports shared build configurations, allowing formatting rules to be distributed and loaded acr
Cake is a cross-platform build automation system and scripting framework that allows users to define software build pipelines using C# scripts. It functions as a CI/CD pipeline orchestrator and build runner, providing a strongly-typed domain-specific language to simplify the orchestration of compilation, testing, and packaging processes across Windows, Linux, and macOS. The system ensures reproducible build environments by pinning the versions of build tools, modules, and dependencies. It distinguishes itself by enabling a C# scripting workflow with full IDE support, including autocomplete, s
lazyssh is a keyboard-driven SSH connection manager and server browser designed for remote host administration. It provides a centralized interface to organize, filter, and launch secure shell sessions to multiple remote servers. The tool features a fuzzy-search server browser that allows for rapid location of hosts by alias, IP address, or tags. It includes an integrated configuration editor for managing host entries and a session orchestrator that handles proxy jumps, port forwarding, and identity file assignments. The system further automates connectivity through automatic identity file d