Overmind is a process manager for Procfile-based applications and tmux. With Overmind, you can easily run several processes from your
Procfile in a single terminal.
Procfile is a simple format to specify types of processes your application provides (such as web application server, background queue process, front-end builder) and commands to run those processes. It can significantly simplify process management for developers and is used by popular hosting platforms, such as Heroku and Deis. You can learn more about the
Procfile format here.
There are some good Procfile-based process management tools, including foreman by David Dollar, which started it all. The problem with most of those tools is that processes you want to manage start to think they are logging their output into a file, and that can lead to all sorts of problems: severe lagging, and losing or breaking colored output. Tools can also add vanity information (unneeded timestamps in logs). Overmind was created to fix those problems once and for all.
See this article for a good intro and all the juicy details! Introducing Overmind and Hivemind
You may know several Procfile process management tools, but Overmind has some unique, extraterrestrial powers others don't:
If a lot of those features seem like overkill for you, especially the tmux integration, you should take a look at Overmind's little sister — Hivemind!
Note: At the moment, Overmind supports Linux, *BSD, and macOS only.
Overmind works with tmux, so you need to install it first:
# on macOS (with homebrew) $ brew install tmux # on Ubuntu $ apt-get install tmux
Note: You can find installation manuals for other systems here: tmux/tmux
There are three ways to install Overmind:
brew install overmind
You can download the latest release here.
You need Go 1.17 or later to build the project.
$ go install github.com/DarthSim/overmind/v2
The Overmind binary will be installed to
$(go env GOPATH)/bin. Make sure that you added it to your
Note: You can update Overmind the same way.
In short: You can get help by running
overmind -h and
overmind help [command].
Overmind reads the list of processes you want to manage from a file named
Procfile. It may look like this:
web: bin/rails server worker: bundle exec sidekiq assets: gulp watch
To get started, you just need to run Overmind from your working directory containing a
$ overmind start
You can also use the short alias:
$ overmind s
Procfile isn't located in your working directory, you can specify the exact path:
$ overmind start -f path/to/your/Procfile $ OVERMIND_PROCFILE=path/to/your/Procfile overmind start
Overmind sets the environment variable
PORT for each process in your Procfile so that you can do things like this:
web: bin/rails server -p $PORT
Overmind assigns the port base (5000 by default) to
PORT for the first process and increases
PORT by port step (100 by default) for each subsequent one. You can specify the port base and port step like this:
$ overmind start -p 3000 -P 10 $ OVERMIND_PORT=3000 OVERMIND_PORT_STEP=10 overmind start
If you don't want Overmind to set the
PORT variable, you can disable it:
$ overmind start -N $ OVERMIND_NO_PORT=1 overmind start
You can specify the names of processes you want to run:
$ overmind start -l web,sidekiq $ OVERMIND_PROCESSES=web,sidekiq overmind start
Similar to the above, if there are some processes in the Procfile that you do not want to run:
$ overmind start -x web,sidekiq $ OVERMIND_IGNORED_PROCESSES=web,sidekiq overmind start
This takes precedence over the previous
-l flag. i.e. if you:
$ overmind start -l web -x web $ OVERMIND_IGNORED_PROCESSES=web OVERMIND_PROCESSES=web overmind start
Nothing will start.
By default, Overmind starts one instance of each process, but you can set the number of each process instances to run:
$ overmind start -m web=2,worker=5 $ OVERMIND_FORMATION=web=2,worker=5 overmind start
There is a special name
all that you can use to scale all processes at once:
$ overmind start -m all=2,worker=5 $ OVERMIND_FORMATION=all=2,worker=5 overmind start
If you set instances number of some process to zero, this process won't be run:
$ overmind start -m some_production_task=0 $ OVERMIND_FORMATION=some_production_task=0 overmind start
Usually, when a process dies, Overmind will interrupt all other processes. However, you can specify processes that can die without interrupting all other ones:
$ overmind start -c assets,npm_install $ OVERMIND_CAN_DIE=assets,npm_install overmind start
Also, you can allow all processes to die:
$ overmind start --any-can-die $ OVERMIND_ANY_CAN_DIE=1 overmind start
If some of your processes tend to randomly crash, you can tell Overmind to restart them automatically when they die:
$ overmind start -r rails,webpack $ OVERMIND_AUTO_RESTART=rails,webpack overmind start
Overmind colorizes process names with different colors. It may happen that these colors don't match well with your color scheme. In that case, you can specify your own colors using xterm color codes:
$ overmind start -b 123,123,125,126,127 $ OVERMIND_COLORS=123,123,125,126,127 overmind start
If you want Overmind to always use these colors, you can specify them in the environment file located in your home directory.
By default, Overmind doesn't show timestamps in its output since it expects your processes to add timestamps to their own output. But you can make Overmind to add timestamps to its output:
$ overmind start -T $ OVERMIND_SHOW_TIMESTAMPS=1 overmind start
If you need to gain access to process input, you can connect to its
$ overmind connect <process_name>
You can safely disconnect from the window by hitting
Ctrl b (or your tmux prefix) and then
You can omit the process name to connect to the first process defined in the Procfile.
You can restart a single process without restarting all the other ones:
$ overmind restart sidekiq
You can restart multiple processes the same way:
$ overmind restart sidekiq assets
It's also possible to use wildcarded process names:
$ overmind restart 'sidekiq*'
When the command is called without any arguments, it will restart all the processes.
You can stop a single process without stopping all the other ones:
$ overmind stop sidekiq
You can stop multiple processes the same way:
$ overmind stop sidekiq assets
It's also possible to use wildcarded process names:
$ overmind stop 'sidekiq*'
When the command is called without any arguments, it will stop all the processes without stopping Overmind itself.
If something goes wrong, you can kill all running processes:
$ overmind kill
If you need to set specific environment variables before running a
Procfile, you can specify them in the
.overmind.env file in the current working directory, your home directory, or/and in the
.env file in in the current working directory. The file should contain
variable=value pairs, one per line:
PATH=$PATH:/additional/path OVERMIND_CAN_DIE=npm_install OVERMIND_PORT=3000
For example, if you want to use a separate
Procfile.dev by default on a local environment, create
.overmind.env file with
OVERMIND_PROCFILE=Procfile.dev. Now, Overmind uses
Procfile.dev by default.
You can specify additional env files to load with
$ OVERMIND_ENV=./.env.local,./.env.development overmind s
The files will be loaded in the following order:
You can also opt to skip loading the
.env file entirely (
.overmind.env will still be read) by setting the variable
Since you set up an environment with
.env files, you may want to run a command inside this environment. You can do this using
$ overmind run yarn install
Overmind can be run as a daemon:
$ overmind start -D $ OVERMIND_DAEMONIZE=1 overmind start
echo command for the logs:
$ overmind echo
You can quit daemonized Overmind with
$ overmind quit
Overmind receives commands via a Unix socket. Usually, it opens a socket named
.overmind.sock in a working directory, but you can specify the full path:
$ overmind start -s path/to/socket $ OVERMIND_SOCKET=path/to/socket overmind start
All other commands support the same flag:
$ overmind connect -s path/to/socket web $ overmind restart -s path/to/socket sidekiq $ overmind kill -s path/to/socket
Overmind can bind its command center to a TCP address instead of Unix socket. This is useful when you run it on a remote machine.
$ overmind start -s "0.0.0.0:4321" -S "tcp" $ OVERMIND_SOCKET="0.0.0.0:4321" OVERMIND_NETWORK="tcp" overmind start
You need to pass the same flags to other commands:
$ overmind connect -s "0.0.0.0:4321" -S "tcp" web
Overmind can use a specified tmux config. This is useful if you want to differentiate from your main tmux window, for example adding a custom status line for Overmind or a different prefix key.
overmind start -F ~/overmind.tmux.conf OVERMIND_TMUX_CONFIG=~/.overmind.tmux.conf overmind start
This may happen if your Ruby/Node/etc version manager isn't configured properly. Make sure that the path to your custom binaries is included in your
PATH before the system binaries path.
Unfortunately, this is how Docker works. When you send
SIGINT to a
docker run ... process, it just detaches container and exits. You can solve this by using named containers and signal traps:
mydocker: trap 'docker stop mydocker' EXIT > /dev/null; docker run --name mydocker ...
bind: invalid argumenterror
All operating systems have limits on Unix socket path length. Try to use a shorter socket path.
pg_ctl --wait startand keeps PostgreSQL server running
Since version 12.0
pg_ctl --wait start exits right after starting the server. Just use the
postgres command directly.
Sergey "DarthSim" Aleksandrovich
Highly inspired by Foreman.
Many thanks to @antiflasher for the awesome logo.
Overmind is licensed under the MIT license.
See LICENSE for the full license text.