parallelshell vs concurrently vs npm-run vs npm-run-all
NPM Script Management Tools
Search packages..
parallelshellconcurrentlynpm-runnpm-run-allSimilar Packages:

NPM Script Management Tools

NPM script management tools are utilities that help developers run multiple npm scripts concurrently or sequentially. These tools are particularly useful in complex projects where tasks like building, testing, and deploying need to be automated efficiently. They provide features like running scripts in parallel, handling dependencies between tasks, and improving the overall workflow in a development environment. These tools help streamline the execution of multiple scripts, making the development process more efficient and organized. concurrently is a tool that allows you to run multiple commands concurrently, displaying their output in a single terminal. It is simple to use and is ideal for running tasks like starting a server and a client simultaneously. npm-run is a lightweight utility for running npm scripts programmatically. It is useful for automating tasks within Node.js applications but does not provide features for running multiple scripts concurrently. npm-run-all is a CLI tool that allows you to run multiple npm scripts sequentially or concurrently. It provides more control over the execution order of scripts and is useful for complex workflows that require running tasks in a specific sequence or in parallel. parallelshell is a tool for running multiple shell commands in parallel. It is similar to concurrently but focuses on running shell commands rather than npm scripts. It is useful for tasks that require running multiple commands simultaneously, such as building multiple projects or running tests in parallel.

Npm Package Weekly Downloads Trend

3 Years

Github Stars Ranking

Stat Detail

Package
Downloads
Stars
Size
Issues
Publish
License
parallelshell9,689498-209 years agoMIT
concurrently07,812411 kB58a month agoMIT
npm-run0187-68 years agoMIT
npm-run-all05,837-1148 years agoMIT

Feature Comparison: parallelshell vs concurrently vs npm-run vs npm-run-all

Concurrency

  • parallelshell:

    parallelshell allows you to run multiple shell commands in parallel. It is similar to concurrently but focuses on shell commands rather than npm scripts.

  • concurrently:

    concurrently allows you to run multiple commands or scripts at the same time, displaying their output in a single terminal. It is designed specifically for running tasks concurrently and provides features like color-coded output to distinguish between commands.

  • npm-run:

    npm-run does not support running multiple scripts concurrently. It is designed for running a single npm script programmatically.

  • npm-run-all:

    npm-run-all supports running multiple npm scripts either sequentially or concurrently. It provides more flexibility in how scripts are executed, allowing you to choose the mode that best fits your workflow.

Script Management

  • parallelshell:

    parallelshell does not provide features for managing the execution order of commands. It simply runs all specified commands in parallel.

  • concurrently:

    concurrently is focused on running multiple commands or scripts concurrently but does not provide features for managing the execution order or dependencies between scripts.

  • npm-run:

    npm-run is a simple tool for running a single npm script programmatically. It does not provide features for managing multiple scripts or their execution order.

  • npm-run-all:

    npm-run-all provides features for managing the execution order of multiple npm scripts. You can run scripts sequentially, concurrently, or a combination of both, making it ideal for complex workflows.

Output Handling

  • parallelshell:

    parallelshell does not provide any special output handling. The output from all commands is combined, which can make it difficult to distinguish between them.

  • concurrently:

    concurrently provides color-coded output for each command, making it easy to distinguish between the outputs of different scripts. This is particularly useful when running multiple tasks simultaneously.

  • npm-run:

    npm-run does not provide any special output handling. It simply runs the specified npm script and outputs the result to the console.

  • npm-run-all:

    npm-run-all does not provide specialized output handling for concurrent scripts. The output from all scripts is combined, which can make it harder to distinguish between them when running scripts concurrently.

Ease of Use

  • parallelshell:

    parallelshell is straightforward to use for running multiple shell commands in parallel. It requires minimal setup and is easy to integrate into existing workflows.

  • concurrently:

    concurrently is easy to use and requires minimal configuration. You can run multiple commands with a single command, and the color-coded output makes it easy to understand what is happening.

  • npm-run:

    npm-run is simple to use for running a single npm script programmatically. It is lightweight and does not require much setup.

  • npm-run-all:

    npm-run-all is easy to use for running multiple scripts, but it may require some configuration to set up complex workflows. The documentation is clear, and it provides examples for common use cases.

Code Examples

  • parallelshell:

    Running multiple shell commands in parallel with parallelshell

    "scripts": {
  "build-css": "node-sass src/styles -o dist/styles",
  "build-js": "babel src -d dist",
  "build": "parallelshell \"npm run build-css\" \"npm run build-js\""
}
  • concurrently:

    Running multiple commands concurrently with concurrently

    "scripts": {
  "start-server": "node server.js",
  "start-client": "npm start --prefix client",
  "start": "concurrently \"npm run start-server\" \"npm run start-client\""
}
  • npm-run:

    Running a single npm script programmatically with npm-run

    const npmRun = require('npm-run');
npmRun('build', (err, stdout, stderr) => {
  if (err) {
    console.error('Error running build script:', err);
    return;
  }
  console.log('Build script output:', stdout);
});
  • npm-run-all:

    Running multiple npm scripts sequentially or concurrently with npm-run-all

    "scripts": {
  "clean": "rimraf dist",
  "build": "webpack",
  "test": "jest",
  "build-all": "npm-run-all clean build test",
  "build-concurrent": "npm-run-all --parallel clean build test"
}

How to Choose: parallelshell vs concurrently vs npm-run vs npm-run-all

  • parallelshell:

    Choose parallelshell if you need to run multiple shell commands in parallel from the command line. It is simple and effective for running multiple commands simultaneously, but it does not provide features specific to npm scripts.

  • concurrently:

    Choose concurrently if you need a simple and effective way to run multiple commands or scripts at the same time, especially for tasks like running a frontend and backend server simultaneously. It is user-friendly and provides clear output for each command.

  • npm-run:

    Choose npm-run if you need a programmatic way to run npm scripts within your Node.js application. It is lightweight and ideal for automating tasks without the need for running multiple scripts concurrently.

  • npm-run-all:

    Choose npm-run-all if you need to run multiple npm scripts either sequentially or concurrently with more control over the execution order. It is ideal for complex workflows that require running tasks in a specific sequence or in parallel.

Similar Npm Packages to concurrently

concurrently is a command-line utility that allows developers to run multiple npm scripts concurrently in a single command. This is particularly useful in development environments where you may need to start multiple processes, such as a server and a client, or run various build tasks simultaneously. By using concurrently, developers can streamline their workflow and improve productivity by managing multiple tasks without having to open separate terminal windows.

While concurrently is a popular choice for running multiple scripts, there are several alternatives available that offer similar functionality. Here are a few noteworthy options:

  • npm-run-all is a command-line tool that allows you to run multiple npm scripts sequentially or in parallel. It provides a simple syntax to define how scripts should be executed, making it easy to manage complex workflows. Unlike concurrently, which focuses solely on parallel execution, npm-run-all gives you the flexibility to choose between running scripts in sequence or concurrently, depending on your needs. This makes it a versatile option for developers who require more control over their script execution order.

  • npm-watch is another alternative that focuses on running npm scripts in response to file changes. It watches specified files or directories and automatically executes defined scripts when changes are detected. This is particularly useful in development environments where you want to automate tasks like rebuilding assets or restarting a server whenever you make changes to your code. While npm-watch is not a direct replacement for concurrently, it complements it by providing a way to automate script execution based on file changes.

To explore how these packages compare, check out the following link: Comparing concurrently vs npm-run-all vs npm-watch.

Similar Npm Packages to npm-run

npm-run is a utility package that simplifies the execution of npm scripts in a more flexible and convenient manner. It allows developers to run scripts defined in their package.json file without needing to type out the full command each time. This can be particularly useful for projects with multiple scripts, as it streamlines the process of running tasks such as building, testing, or starting a development server. By providing a more user-friendly interface for script execution, npm-run enhances productivity and reduces the likelihood of errors when running commands.

One notable alternative to npm-run is npm-watch. This package is designed to watch files and automatically run npm scripts when changes are detected. It is particularly useful for development workflows where you want to continuously monitor files for changes and trigger specific tasks, such as rebuilding assets or running tests, without manual intervention. npm-watch allows developers to define watch scripts in their package.json, making it easy to set up and manage file watching in a project.

To see how npm-run compares with npm-watch, check out the comparison: Comparing npm-run vs npm-watch.

Similar Npm Packages to npm-run-all

npm-run-all is a command-line utility that allows developers to run multiple npm scripts in parallel or sequentially. This package is particularly useful for managing complex build processes or workflows in JavaScript projects, as it simplifies the execution of multiple tasks without the need for additional scripts or manual intervention. By using npm-run-all, developers can streamline their development process, improve efficiency, and reduce the overhead of managing multiple command-line tasks.

While npm-run-all is a powerful tool, there are several alternatives that also provide similar functionality:

  • concurrently is a popular package that enables users to run multiple commands concurrently in the same terminal window. It is particularly useful for running multiple npm scripts simultaneously, such as starting a development server while running tests or building assets. concurrently provides clear output for each command, making it easy to track the progress of each task. If your workflow requires running multiple processes at the same time, concurrently is an excellent choice.
  • npm-run is a simple utility that allows for running npm scripts with additional options. It provides a straightforward way to execute scripts defined in the package.json file without the need for complex command-line syntax. While it may not offer the same level of parallel execution as npm-run-all or concurrently, it is a lightweight option for those who want to streamline their npm script execution.
  • parallelshell is another alternative that allows users to run multiple shell commands in parallel. It provides a simple interface for executing multiple commands simultaneously and is particularly useful for running scripts that do not depend on each other. While it may not be as widely used as some of the other options, it serves as a lightweight solution for parallel command execution.

To see how npm-run-all compares with concurrently, npm-run, and parallelshell, check out the comparison: Comparing concurrently vs npm-run vs npm-run-all vs parallelshell.

README for parallelshell

Parallel Shell

This is a super simple npm module to run shell commands in parallel. All processes will share the same stdout/stderr, and if any command exits with a non-zero exit status, the rest are stopped and the exit code carries through.

Version compatibility notes

  • Fully compatible with Node up to v8 and later!

Maintenance has been resumed by @darkguy2008. However, there are also better options, see Consolidation of multiple similar libraries.

Motivation

How is this different than:

$ cmd1 & cmd2 & cmd3

  • Cross platform -- works on Unix or Windows.

  • & creates a background process, which only exits if you kill it or it ends. parallelshell will autokill processes if one of the others dies.

  • command1 & command2 & command3 will wait in the terminal until command3 ends only. parallelshell will wait until all 3 end.

  • If command1 or command2 exit with non-zero exit code, then this will not effect the outcome of your shell (i.e. they can fail and npm/bash/whatever will ignore it). parallelshell will not ignore it, and will exit with the first non-zero exit code.

  • Pressing Ctrl+C will exit command3 but not 1 or 2. parallelshell will exit all 3

  • parallelshell outputs all jobs stdout/err to its stdout/err. background jobs do that... kind of coincidentally (read: unreliably)

So what's the difference between GNU parallel and this?

The biggest difference is that parallelshell is an npm module and GNU parallel isn't. While they probably do similar things, albeit (GNU) parallel being more advanced, parallelshell is an easier option to work with when using npm (because it's an npm module).

If you have GNU parallel installed on all the machines you project will be on, then by all means use it! :)

Install

Simply run the following to install this to your project:

npm i --save-dev parallelshell

Or, to install it globally, run:

npm i -g parallelshell

Usage

To use the command, simply call it with a set of strings - which correspond to shell arguments, for example:

parallelshell "echo 1" "echo 2" "echo 3"

This will execute the commands echo 1 echo 2 and echo 3 simultaneously.

Note that on Windows, you need to use double-quotes to avoid confusing the argument parser.

Available options:

-h, --help         output usage information
-v, --verbose      verbose logging
-w, --wait         will not close sibling processes on error
npm-compare.com is an independent website designed to help developers choose the most suitable npm packages. We are not affiliated with npm, Inc, the official website for the npm registry. Note that npm is a registered trademark of npm, Inc. For more details, please refer to our Terms & Privacy.