Does lpm read my Procfile?

Once. When you add the folder, lpm opens Procfile.dev (or Procfile, if that is all there is) and makes each line a service, keeping its name, its command and any -p port. After that the list is lpm's own, so a line you add to the Procfile later has to be added in lpm too. The file itself is never touched — it stays in the repo for Heroku and foreman export.

What replaces bin/dev in a Rails app?

bin/dev shells out to Foreman with Procfile.dev. With lpm you press Start, or run lpm start, and the same lines come up as separate panes. Keep bin/dev working — nothing removes it.

Does lpm load .env the way foreman start does?

No. lpm exports the env: map you write on each service, so move the variables you need there or keep loading .env inside the command with dotenv.

Does lpm replace foreman export?

No. If you use foreman export to generate upstart, systemd, or launchd unit files for deploy, keep using Foreman for that. lpm is focused on the local dev loop — starting the stack on your machine, viewing live output per service, and switching between projects — not on producing init-system artifacts for servers.

Does it run on Linux or Windows?

Foreman is a Ruby gem that runs on Linux as well as macOS, and Overmind covers Linux, *BSD and macOS; neither documents a Windows setup. lpm is the odd one out — its window opens on a Mac and nowhere else. A Linux server can still be where your Rails processes actually run, with the Mac driving them.

All comparisons

Procfile dev on macOS

Foreman vs Overmind for a Rails Procfile — and a third option.

Both read the same Procfile.dev. Foreman interleaves everything on one stdout stream, Overmind gives each process a tmux window, and lpm gives every line a live pane of its own.

If your Procfile.dev is two lines and nothing ever crashes, Foreman is still the answer.

Download for macOSApple SiliconDownload for macOS (Apple Silicon)Intel Mac? Get the x86-64 build

Developer ID signed · Notarized by AppleSafety, checksums & removal

See all three side by side

View on GitHub

Facts checked September 23, 2026. The foreman gem sits at 0.90.0 from July 2025; Overmind's newest tag, v2.5.1, is from March 2024. Every lpm cell was re-read off the app's own source.

The short answer

Foreman or Overmind for a Rails Procfile?

Overmind, if you want to attach to or restart one process without touching the rest — it runs each process in its own tmux window to make that possible, and -m web=2,worker=3 scales one of them. Foreman, if one interleaved stream on stdout is all you need, if you would rather not install tmux, or if your deploy depends on foreman export.

There is a third shape. foreman start puts your whole stack in one terminal, and when the CSS watcher dies it takes Rails with it. lpm runs the same web, css and worker lines as separate live panes on macOS — restart one, leave the rest alone, and quit the app without killing anything. Add the folder and lpm reads Procfile.dev for you, one service per line, with the -p 3000 kept as the port it watches.

Procfile.dev

web: bin/rails server -p 3000
css: bin/rails tailwindcss:watch
worker: bundle exec sidekiq

What lpm lists after you add the folder

services:
  web:
    cmd: bin/rails server -p 3000
    port: 3000
  css:
    cmd: bin/rails tailwindcss:watch
  worker:
    cmd: bundle exec sidekiq

That is the whole migration, and nobody types it. What changes is not the declaration — it is that worker can crash without taking web down with it.

Foreman

Keep Foreman

Two lines in Procfile.dev, $PORT assigned for you, .env loaded automatically, and foreman export generating the launchd or systemd units your deploy needs.

Overmind

Keep Overmind

overmind connect web to attach one process, restart it without the rest, -m web=2 to scale it, and Linux or *BSD support.

lpm

Switch to lpm

A pane per process, a project switcher across repos, services that outlive the app, and Claude Code or Codex in the next tab. Mac only, and it takes Procfile.dev in once, as the project is added, rather than on every start.

Why people leave foreman start

Four things that happen in one terminal

The CSS watcher dies and takes Rails with it

One process exits and the whole formation shuts down mid-request.

In lpm each service is its own pane; nothing stops the siblings when one exits, and you bring that one back with lpm service css restart, or by switching it off and on again in the project's Services menu. Overmind restarts one too — that is what it exists for — though there a dying process interrupts the rest unless you list it under -c.

Closing the window ends your stack

lpm's services run outside the app, so quitting it leaves the dev servers up and relaunching finds them again. Overmind's tmux session detaches and keeps going; a foreman formation ends with the command that started it.

Address already in use, and you do not know who

lpm checks the ports your services declare before it starts, names the process holding one, and offers to free it or stop the start.

Postgres has to be up before the worker

dependsOn: [db] gives a real start order, with a clear error instead of a hang if you write a cycle. It orders starts; lpm wait --port 5432 is the readiness gate.

All three, side by side

The same three lines, three ways

Nine of these twenty-one rows go to Foreman or Overmind. They are the first nine.

Capability	lpm	Foreman	Overmind
Re-reads Procfile.dev every time it starts	imports it once, when you add the folder	Yes	Yes
Sets $PORT for each process type	you write it in env:	-p base, +100 a line	-p base, -P step
Reads a .env file without being asked	No	.env in the working directory	.overmind.env, then .env
All output interleaved on one stdout stream	No	Yes	No
Exports launchd or systemd units for deploy	No	foreman export	No
Installs on a Windows or Linux workstation	Mac app; Linux only as a remote host	Linux, macOS	Linux, *BSD, macOS
Attach a shell to one running process	panes are read-only	No	overmind connect
Run two copies of web from one line	one entry, one process	-m web=2	-m web=2
One command brings the whole stack up	one click, or lpm start with the app running	Yes	Yes
A live pane per process, all visible at once	Yes	No	a tmux window each
Restart css without restarting web	lpm service css restart	No	overmind restart css
One process dying leaves the others alive	Yes	one exit ends the formation	only with -c or --any-can-die
The stack outlives the terminal you started it in	quit the app, services stay up	No	its tmux session, detach with Ctrl-b d
What you install before the first run	the app; no tmux, no Ruby	Ruby, then the gem	tmux, then the binary
Redis is started before Sidekiq	dependsOn: [redis]	No	No
Names what is already holding :3000	Yes	No	No
Run a named subset instead of a per-run flag	profiles:	-m web=2,worker=0	-l web,worker
Two Rails apps up at once in one window	Yes	No	No
A second Claude Code or Codex agent gets its own checkout	1–50 worktrees or copies	No	No
A desktop window rather than a foreground command	Yes	a foreground command	a foreground command plus tmux
Licence on the gem, the binary and the app	MIT	MIT	MIT

Re-reads Procfile.dev every time it starts
lpm
imports it once, when you add the folder
Foreman
Yes
Overmind
Yes
Sets $PORT for each process type
lpm
you write it in env:
Foreman
-p base, +100 a line
Overmind
-p base, -P step
Reads a .env file without being asked
lpm
No
Foreman
.env in the working directory
Overmind
.overmind.env, then .env
All output interleaved on one stdout stream
lpm
No
Foreman
Yes
Overmind
No
Exports launchd or systemd units for deploy
lpm
No
Foreman
foreman export
Overmind
No
Installs on a Windows or Linux workstation
lpm
Mac app; Linux only as a remote host
Foreman
Linux, macOS
Overmind
Linux, *BSD, macOS
Attach a shell to one running process
lpm
panes are read-only
Foreman
No
Overmind
overmind connect
Run two copies of web from one line
lpm
one entry, one process
Foreman
-m web=2
Overmind
-m web=2
One command brings the whole stack up
lpm
one click, or lpm start with the app running
Foreman
Yes
Overmind
Yes
A live pane per process, all visible at once
lpm
Yes
Foreman
No
Overmind
a tmux window each
Restart css without restarting web
lpm
lpm service css restart
Foreman
No
Overmind
overmind restart css
One process dying leaves the others alive
lpm
Yes
Foreman
one exit ends the formation
Overmind
only with -c or --any-can-die
The stack outlives the terminal you started it in
lpm
quit the app, services stay up
Foreman
No
Overmind
its tmux session, detach with Ctrl-b d
What you install before the first run
lpm
the app; no tmux, no Ruby
Foreman
Ruby, then the gem
Overmind
tmux, then the binary
Redis is started before Sidekiq
lpm
dependsOn: [redis]
Foreman
No
Overmind
No
Names what is already holding :3000
lpm
Yes
Foreman
No
Overmind
No
Run a named subset instead of a per-run flag
lpm
profiles:
Foreman
-m web=2,worker=0
Overmind
-l web,worker
Two Rails apps up at once in one window
lpm
Yes
Foreman
No
Overmind
No
A second Claude Code or Codex agent gets its own checkout
lpm
1–50 worktrees or copies
Foreman
No
Overmind
No
A desktop window rather than a foreground command
lpm
Yes
Foreman
a foreground command
Overmind
a foreground command plus tmux
Licence on the gem, the binary and the app
All three
MIT

Migration

Your Procfile, line by line

Adding the folder brings the three Procfile lines across, and the -p 3000 on web becomes the port lpm watches. What you add by hand is the Redis line a Procfile usually leaves out and the start order it has no room for. Every field is listed in the config reference.

~/.lpm/projects/myapp.yml

services:
  web:
    cmd: bin/rails server -p 3000
    port: 3000
    env:
      PORT: "3000"
  css: bin/rails tailwindcss:watch
  redis:
    cmd: redis-server
    port: 6379
  worker:
    cmd: bundle exec sidekiq
    dependsOn: [redis]

profiles:
  default: [web, css]
  full: [web, css, redis, worker]

$PORT is not set for you.: Foreman assigns a port per process type and Overmind steps one per process. lpm does not: port: is what it watches for conflicts, not something it exports, and an imported line that only says $PORT arrives with no port at all. Set it yourself — env: { PORT: "3000" } — or hard-code the flag the way Rails' own Procfile.dev already does.
.env is not loaded automatically.: foreman start reads .env from the working directory; Overmind reads .overmind.env and then .env. lpm exports exactly the env: map you write, so move the handful of variables you need there, or keep loading .env inside the command with dotenv.
foreman start -m web=2,worker=0 becomes a profile.: profiles: { default: [web, css], full: [web, css, redis, worker] }, then lpm start --profile full. Named subsets instead of a per-run flag — and no process scaling: one entry is one process.
Keep foreman export.: If you generate launchd or systemd units for a server, that is still Foreman's job. lpm has no export; it is the local loop only.

Which verbs need the app running, since this is the one thing foreman start never made you think about. lpm start, lpm stop, lpm run and lpm service css restart are requests to the app, and fail with a usage error when it is closed. lpm list and lpm logs css go straight to the services and answer from any shell, open app or not. lpm status, which reports what your agents are doing, needs it too.

See it

rails db:migrate as a button

The one-off commands you run with foreman run become actions you click, or call with lpm run.

Honest take

When each one is the right tool

Both start the same commands from the same one-line declaration. The split is what happens after they are running.

Pick lpm

Your stack has more than two processes, or a second agent is about to want its own copy of it.

You want the CSS watcher to die on its own without taking Rails down, and to bring just that one back.
A pane per process beats scrolling one stream to find which one printed the error.
You quit the app at lunch and want the dev servers still up when you get back.
Two or three repos are up at once and you would rather click between them than count terminal tabs.
Claude Code or Codex is about to want its own checkout of this project — anywhere from 1 to 50 of them. A linked worktree arrives without your .env, and lpm's Install dependencies covers Node packages, not a bundle install.
lpm does not lock the project in — it runs the same commands your Procfile already names.

Pick Foreman or Overmind

The Procfile runner you already have is enough.

Your Procfile.dev is two lines and neither of them ever crashes (Foreman).
You want $PORT assigned and .env loaded without writing either down (both).
foreman export generates the units your deploy depends on (Foreman).
One interleaved stream is genuinely how you read your app (Foreman).
You need overmind connect and per-process restart, and tmux is already installed (Overmind).
Someone on the team develops on Linux (Foreman and Overmind both run there; Overmind on *BSD too).

See it in actionLive interactive demo

Add a folder, and it becomes a project

Add a Rails app, get a pane per Procfile line, restart css alone

A short video: pick a folder or clone a repo, and it joins the sidebar.Click anything — the Rails stack runs in your browser.

lpm is a macOS app with a multi-pane terminal workspace. Open this page on your computer to try the interactive demo.

Get lpm for Mac Or check your Macs from your iPhone

Click a step to run it in the window.

Done poking around? Get lpm for Mac and point it at your own projects.

FAQ

Foreman, Overmind and lpm — the honest answers

Foreman or Overmind — which should I use?
Overmind, if you want to attach to or restart one process without touching the rest — it runs each process in its own tmux window to make that possible, and -m web=2,worker=3 scales one of them. Foreman, if one interleaved stream on stdout is all you need, if you would rather not install tmux, or if your deploy depends on foreman export.
Does lpm read my Procfile?
Once. When you add the folder, lpm opens Procfile.dev (or Procfile, if that is all there is) and makes each line a service, keeping its name, its command and any -p port. After that the list is lpm's own, so a line you add to the Procfile later has to be added in lpm too. The file itself is never touched — it stays in the repo for Heroku and foreman export.
What replaces bin/dev in a Rails app?
bin/dev shells out to Foreman with Procfile.dev. With lpm you press Start, or run lpm start, and the same lines come up as separate panes. Keep bin/dev working — nothing removes it.
Does lpm load .env the way foreman start does?
No. lpm exports the env: map you write on each service, so move the variables you need there or keep loading .env inside the command with dotenv.
Does lpm replace foreman export?
No. If you use foreman export to generate upstart, systemd, or launchd unit files for deploy, keep using Foreman for that. lpm is focused on the local dev loop — starting the stack on your machine, viewing live output per service, and switching between projects — not on producing init-system artifacts for servers.
Does it run on Linux or Windows?
Foreman is a Ruby gem that runs on Linux as well as macOS, and Overmind covers Linux, *BSD and macOS; neither documents a Windows setup. lpm is the odd one out — its window opens on a Mac and nowhere else. A Linux server can still be where your Rails processes actually run, with the Mac driving them.

Three lines in a Procfile. Three panes on your Mac.

lpm starts the same commands your Procfile.dev already names, one pane each, and leaves them running when you quit the app. Free, MIT-licensed, macOS.