CLI tool
open-cli-tools/concurrently avatar
open-cli-tools/concurrently

concurrently: quoted arguments, prefixed output, and --kill-others

Run commands concurrently. Like `npm run watch-js & npm run watch-less` but better.

7,870 stars288 forksTypeScriptMIT

At a glance

What is it?
open-cli-tools/concurrently replaces `npm run watch-js & npm run watch-css` with a cross-platform runner that labels each process's output and can take the whole group down when one command fails. The awkward parts are not the features but three details: argument quoting, shell resolution, and a Node 22 floor.
Who is it for?
concurrently suits a Node project whose dev script starts three or four watchers at once and where a silent background failure is the actual problem, since the prefixed output and --kill-others are built for exactly that. It does not suit you if you want a full task runner, because the unit of work here is a shell command.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 3 days ago.
What is it written in?
Mainly TypeScript, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 16, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • open-cli-tools/concurrently7,870 ★ · +17
Star history
Repository2026-09-222026-11-16
open-cli-tools/concurrently7.9k7.9k

17 Stars in the last 55 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

Unquoted arguments become separate commands, which is the first surprise

The documented way to pass a command with arguments is to quote the whole thing:

bash
concurrently 'command1 arg' 'command2 arg'

Without the quotes, concurrently tries to run four separate commands: `command1`, `arg`, `command2`, `arg`. Two of those do not exist, so you get failures that look like a broken tool rather than a broken shell line.

Windows has its own rule on top of that: only double quotes are supported, and the double quotes have to be escaped again inside package.json:

json
"start": "concurrently \"command1 arg\" \"command2 arg\""

Two small conveniences are worth knowing: the binary is also available as `conc`, so scripts can be shorter, and you can always check the flags with `concurrently --help` and the version with `concurrently --version`. Longer examples live in the `docs` directory rather than in the README.

--kill-others exists because a failed watcher used to stay silent

The reason the tool exists is in the README's own words. Task automation with npm is fine, but the usual way to run several commands is `npm run watch-js & npm run watch-css`, and that is hard to follow because the outputs are interleaved. Worse, if one process fails the others keep running and you may not notice the difference.

So the design has three features and they map one to one onto those complaints. Cross platform, including Windows, is the first. Prefixed output is the second, so you can tell which process wrote which line. The third is the `--kill-others` switch, which kills everything when one command dies.

The programmatic equivalent is the `killOthersOn` option, which takes an array of the strings `success` for a zero exit status and `failure` for a non-zero one, so you can decide whether a clean early exit should also bring the group down.

successCondition decides whether the first finisher or the last one decides the run

When several commands exit, something has to decide whether the run counts as a success. `successCondition` is that switch, and it has two named values.

With `first`, only the first process to exit determines the outcome of the run. With `last`, the final process to exit does.

The choice is not cosmetic in a dev script that starts a web server and a watcher. A server that exits immediately with a bound-port error would, under `first`, decide the fate of the whole run even if the watcher is healthy. That is exactly the case `--kill-others` is for, so the two settings usually travel together.

Prefixes are a template language, and colours can be automatic

The prefix that labels each process's output takes one of a fixed set of values: `index`, `pid`, `time`, `command`, `name` or `none`. The default is the process name, or its index when no name is set, which is why an unnamed command still gets a label.

It also accepts a template such as `[{time} process: {pid}]`. Templates can restrict colouring to part of the prefix with `{color}` and `{/color}`, for example `[{color}{name}{/color}]` to colour only the name and leave the brackets plain, and if either marker is missing the other side is treated as implicit, so a template with no markers is coloured in full.

`prefixColors` takes a list of colours or a string in the form Chalk supports, plus an `auto` value that picks a colour automatically. If you run more commands than you have colours, the last colour repeats, unless that last value is `auto`, in which case the following colours are varied automatically. A colour set on an individual command takes precedence over the list, and `prefixLength` decides how many characters show when the prefix is the command itself, defaulting to 10.

The shell comes from npm_config_script_shell, then from the platform default

Command strings are handed to a shell, and which shell is not fixed. The `shell` option names the executable explicitly. When you leave it unset, concurrently uses `npm_config_script_shell` if that variable is present, which is what happens when you run it from an npm script, and otherwise falls back to `cmd.exe` on Windows or `/bin/sh` everywhere else.

That fallback is the part that bites in cross-platform scripts: the same command line can be valid under `cmd.exe` and invalid under `/bin/sh`, or the reverse. The resolution order is documented separately in the shell resolution page in `docs`, which is the file to read when a command behaves differently on one operating system.

Input handling has its own set of switches. `handleInput` reads from `process.stdin`, `inputStream` takes any Readable stream and overrides `handleInput`, `defaultInputTarget` is `0` by default, and `pauseInputStreamOnFinish` pauses the stream once every process has finished, which you turn off when something still needs to read it afterwards.

Node 22 or newer, ESM only, and two bin entries

The manifest is where the current requirements live. `engines` asks for Node 22 or newer, `type` is set to module, and the version is 10.0.6 with a pinned `packageManager` of pnpm 10.18.2.

Because the package is ESM, the `exports` map has two entries and one of them is `./package.json`.

There are still two bin entries pointing at the same file: `concurrently` and the `conc` shorthand. The published `files` list ships `dist`, a tsbuildinfo file and `docs`, while excluding spec files and `__fixtures__`, so the tests stay out of the tarball.

For contributors the scripts are conventional: `build` runs `tsc --build`, `postbuild` makes the bin executable, `test` runs the unit project and `test:smoke` the smoke project under vitest, and `prepare` runs husky.

The same code is a library, and the dependency list shows the design

concurrently can be imported as well as run. The entry point exports a `concurrently(commands[, options])` function, and the commands are an array whose items are either strings or objects with the shape `{ command, name, prefixColor, env, cwd, ipc }`. Per-command overrides for cwd, raw mode and prefix colour are why those fields exist on the command object rather than only in the options.

The runtime dependencies describe how much of the work is done where. `yargs` parses the flags, `chalk` and `supports-color` handle colouring and detection, `shell-quote` does the parsing that sits behind argument handling, `tree-kill` is what makes killing a process group possible rather than just a child, and `rxjs` is also a runtime dependency.

So if you need something the CLI does not expose, the programmatic API is the documented route, and it is versioned as carefully as the command: releases v10.0.6 and v9.2.5 on 2026-10-08 and v10.0.5 on 2026-08-15, with the last push on 2026-10-25.

Editorial conclusion

concurrently suits a Node project whose dev script starts three or four watchers at once and where a silent background failure is the actual problem, since the prefixed output and --kill-others are built for exactly that. It does not suit you if you want a full task runner, because the unit of work here is a shell command. Verify three things before you adopt it in a shared repo: that each command is quoted, since an unquoted argument becomes its own process, that your Node version clears the declared floor of 22, and which shell your commands run under, because the default follows npm_config_script_shell and otherwise lands on cmd.exe or /bin/sh depending on the platform.

Frequently asked questions

how to install concurrently

Globally or locally, across four package managers. Global is `npm i -g concurrently`, `yarn global add concurrently`, `pnpm add -g concurrently` or `bun add -g concurrently`. Local is `npm i -D concurrently`, `yarn add -D concurrently`, `pnpm add -D concurrently` or `bun add -d concurrently`, and the README recommends adding it to devDependencies since it is normally a development tool.

how to install concurrently using npm

Use `npm i -D concurrently` to add it to a specific package, usually as a devDependency, or `npm i -g concurrently` to make it available system wide. The manifest requires Node 22 or newer, and the CLI is also exposed under the shorthand `conc`.

how to use concurrently

Quote each whole command, for example `concurrently 'command1 arg' 'command2 arg'`, because unquoted arguments are treated as separate commands and Windows only supports double quotes. Add prefixes with the prefix options, use `--kill-others` to stop everything when one command dies, and check the full flag list with `concurrently --help`.

what is concurrently

A Node.js command line tool for running multiple commands at the same time with clearly prefixed output, cross platform including Windows, and able to kill the remaining commands when one of them dies. It can also be used programmatically through a concurrently(commands, options) function, where commands are strings or objects with command, name, prefixColor, env, cwd and ipc fields.

Official sources

  1. License: MIT
  2. open-cli-tools/concurrently on GitHub
  3. Project website
  4. README
  5. Releases
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/open-cli-tools-concurrently.svg)](https://hysenlabs.com/projects/open-cli-tools-concurrently)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/open-cli-tools-concurrently.svg)](https://hysenlabs.com/projects/open-cli-tools-concurrently)

Was this useful?