Installation

Three routes, shortest first. None of them needs a system dependency: lazyshell is a single self-contained binary.

Requirements

macOS or Linux. Windows is out of scope: no Unix pty.
A terminal with 256-colour support (sessions are told xterm-256color by default, and that is configurable).
To build it yourself: Go, at the version pinned in go.mod.

Prebuilt binary

No Go toolchain needed: download the archive for your OS and architecture from the releases page, check it against checksums.txt, then extract lazyshell into a directory on your PATH.

$ tar xzf lazyshell_<os>_<arch>.tar.gz
$ sudo mv lazyshell /usr/local/bin/
$ lazyshell --version

macOS. A binary downloaded outside the App Store is quarantined by Gatekeeper. If launching is refused, allow the executable under System Settings → Privacy & Security, or clear the attribute: xattr -d com.apple.quarantine /usr/local/bin/lazyshell.

Or let a script do the download, checksum verification, and extraction for you (Linux and macOS, amd64/arm64):

$ curl -fsSL https://raw.githubusercontent.com/thomas-gleizes/lazyshell/main/scripts/install.sh | bash

With Go

$ go install github.com/thomas-gleizes/lazyshell/cmd/lazyshell@latest

The binary lands in $(go env GOPATH)/bin — make sure that directory is on your PATH. This route does not fill in the version metadata injected at release time, so lazyshell --version will say less than it does for an official archive.

From source

$ git clone https://github.com/thomas-gleizes/lazyshell.git
$ cd lazyshell
$ make build   # produces ./bin/lazyshell

make build is just shorthand for go build -o bin/lazyshell ./cmd/lazyshell. See the development page for tests and the linter.

Verify the install

$ lazyshell --version
$ lazyshell config init   # writes a fully commented config file
$ lazyshell               # opens the interface

On a first run the interface opens with no sessions at all: n creates one. If you start lazyshell in a repository that carries a lazyshell.yml, it will first ask you to approve that file — see approving a project file.

Updating

lazyshell update replaces the installed binary with the latest release: the same download, checksum check and install as scripts/install.sh, from inside the binary itself.

$ lazyshell update           # install the latest release
$ lazyshell update --check   # only say whether there is a newer one

The new binary is written next to the old one and moved into place in a single step, so an interrupted update leaves the old version intact, never half of either. Running it from inside a running lazyshell is fine — the sessions already open keep the version they started with, so restart lazyshell to use the new one.

Two cases where it stops and tells you instead:

The binary's directory is not writable (/usr/local/bin usually isn't). Re-run it as sudo $(command -v lazyshell) update.
The installed version is not a published release — a go install from main, or a local make build. Replacing it with a release would throw away what you built, so it asks for lazyshell update --force.

--force also reinstalls when you are already up to date.