Inline is a terminal workspace for running and monitoring multiple development processes. Every command gets a separate log screen with fast navigation, automatic following, and scrollback.
Procfile is supported as a first-class, drop-in configuration format—not the boundary of what Inline is designed to become.
- Keep servers, workers, asset builders, tunnels, and log streams in one terminal without mixing their output.
- Give every process an isolated, ANSI-aware log view with line wrapping and up to 20,000 lines of scrollback.
- Move between processes with the keyboard or mouse while active logs automatically follow the latest output.
- Stop the complete process tree cleanly when leaving Inline.
Install the latest release on macOS or Linux:
curl -fsSL https://github.com/maful/inline/releases/latest/download/install.sh | shThe installer supports Intel/AMD and ARM64 systems. It installs into ~/.local/share/inline and links the active version at ~/.local/bin/inline; it never requires sudo.
To inspect the installer before running it:
curl -fsSLO https://github.com/maful/inline/releases/latest/download/install.sh
less install.sh
sh install.shUpdate a standalone installation at any time:
inline updateinline upgrade is an alias. Updates are downloaded into a new versioned directory, checked against the release SHA-256 checksum, and activated only after verification succeeds.
Install the latest tagged version into your Go binary directory:
go install github.com/maful/inline@latestRe-run that command to update a source installation. When working from a clone, install the current checkout with:
go install .Alternatively, build a local binary:
go build -o inline .Print the installed version and distribution channel with:
inline versionAdd a Procfile to the project whose processes you want to run:
web: bin/rails server
js: yarn build --watch
css: yarn watch:css
worker: bundle exec sidekiqEach non-comment line uses the format name: command. Blank lines and lines beginning with # are ignored. Process names must be unique.
From a project containing a Procfile, run:
inlineUse -f to load a differently named file:
inline -f Procfile.devCommands inherit the directory where Inline was launched. Change into the target project before starting Inline when its commands use relative paths.
To run Inline directly from this repository without installing it:
go run . -f Procfile.dev| Key | Action |
|---|---|
↑ / ↓, j / k |
Select a process |
Tab, Shift+Tab, ← / → |
Select the next or previous process |
1–9 |
Jump directly to a process |
r |
Restart the selected process |
PgUp / PgDn, Ctrl+U / Ctrl+D, mouse wheel |
Scroll logs |
g / Home |
Jump to the top and pause following |
G / End |
Jump to the bottom and resume following |
f |
Toggle automatic bottom-follow |
/ |
Edit the selected process's log filter |
Enter / Esc |
Apply or cancel a filter edit |
n / N |
Select the next or previous filter match |
Esc |
Clear the selected process's applied filter |
q, Ctrl+C |
Stop every process and quit |
Each pane shows the process state, PID, and number of captured lines. Long output wraps to the pane width and reflows when the terminal is resized.
Filters are case-insensitive literal searches and are kept separately for each process. Filtering only changes the visible lines: Inline retains the complete 20,000-line scrollback, so clearing or changing a filter restores earlier output. ANSI color codes are ignored while matching and preserved when matching lines are displayed.
Inline highlights each occurrence in the matching lines. Press n or N to select the next or previous occurrence. Selection wraps at both ends.
Restarting preserves the selected process's logs and filter, stops its complete process group, and starts the same Procfile command with a new PID. This lets a development server, worker, or watcher reload changes from disk without restarting the rest of the workspace. Changes to the Procfile itself are not reloaded.
Commands run through the interactive shell named by $SHELL, so shell operators, environment assignments, aliases, and functions from your normal shell setup work normally. Inline falls back to /bin/sh when $SHELL is unavailable.
Some commands suppress output when stdout is not a terminal. For example, ngrok defaults to logging nothing; add --log=stdout to see its connection logs in Inline.
Quitting sends SIGTERM to every managed process group, including child processes. Inline waits up to two seconds before sending SIGKILL to anything still running.
Inline requires Go 1.26.5 or newer. Install the dependencies and build a development binary from the repository root:
go mod download
go build -o /tmp/inline .Launch that binary from a project containing the Procfile you want to exercise:
cd /path/to/project
/tmp/inlineRun the complete verification suite before submitting a change:
go test ./...
go test -race ./...
go vet ./...
go build ./...Test the release configuration locally without publishing:
goreleaser release --snapshot --cleanPublishing a SemVer tag such as v0.1.0 triggers the release workflow. It tests the repository, creates macOS and Linux archives for AMD64 and ARM64, publishes their checksums and install.sh to GitHub Releases, and attests the archives.