Install

gitta is one program, gitta. Install it on each machine where agents work, and on the CI runners that run the pull request check.

Requirements

• Git, a current release. gitta calls the git command on your PATH.
• curl. The install script and gitta update use it to download releases.
• The agents you use, for example Claude Code, Cursor or Codex. They do not need to be installed first.

By platform

FreeBSD is coming next.

Prefer to pick a file yourself? The download page has a binary for each system, each with its checksum.

Install script

The script picks the build for your system and processor, verifies its SHA-256 checksum and puts gitta in ~/.local/bin. Set GITTA_BIN_DIR to install somewhere else.

$ curl -fsSL https://gitta.io/install.sh | sh

The script downloads through gitta.io, which counts the download, and gets the files from GitHub releases if gitta.io does not answer. The count holds the version, the build and the country, and nothing about you. See Privacy.

The script says what it installs, and from which version to which when you upgrade. It then checks your setup and ends with the next steps:

Installing gitta 0.1.0 for macOS, Apple silicon into ~/.local/bin
Done. Checksum verified, gitta installed.

Added ~/.local/bin to your PATH in ~/.zshrc. Open a new terminal, or run:  export PATH="$HOME/.local/bin:$PATH"

Found git 2.50.1.
Found Claude Code. `gitta init` will connect it.

Next steps
  1. Go to your repository:      cd path/to/your/repo
  2. Set it up with your tests:  gitta init --gate "<your test command>"
     for example --gate "pytest", --gate "npm test", --gate "cargo test" or --gate "go test ./..."
  3. See what gitta does:        gitta watch
  Quick start: https://gitta.io/docs/quickstart.html

If ~/.local/bin is not on your PATH, the script adds the line for your shell (zsh, bash or fish) to its startup file, once, and tells you which file it changed. Open a new terminal after that, or run the line it prints.

The script also checks for git. gitta works best with git 2.28 or later. With an older git, gitta still checks every merge, and the script tells you to update git. It looks for Claude Code, Cursor and Codex too, so you know which tools gitta init connects.

Then check the installation:

$ gitta --version
gitta 0.1.0

gitta --help lists every command.

Homebrew

Install from the gitta tap. Each release updates the formula there.

$ brew install gitta-io/tap/gitta

Windows

Run this in PowerShell. You do not need administrator rights.

PS> irm https://gitta.io/install.ps1 | iex

The script picks the build for your processor (x86_64 or arm64), verifies its SHA-256 checksum and puts gitta.exe in %LOCALAPPDATA%\gitta\bin. It adds that folder to your user PATH, so new terminals find gitta, and the window you ran it in finds it at once. Set GITTA_BIN_DIR to install somewhere else. Like the install script for macOS and Linux, it downloads through gitta.io and falls back to GitHub releases.

Installing gitta 0.1.0 for Windows x86_64 into ~\AppData\Local\gitta\bin
Done. Checksum verified, gitta.exe installed.

Added ~\AppData\Local\gitta\bin to your user PATH. New terminals find gitta; this one does too.

Found git 2.51.0.
Found Claude Code. `gitta init` will connect it.

Next steps
  1. Go to your repository:      cd path\to\your\repo
  2. Set it up with your tests:  gitta init --gate "<your test command>"
     for example --gate "pytest", --gate "npm test", --gate "cargo test" or --gate "go test ./..."
  3. See what gitta does:        gitta watch
  Quick start: https://gitta.io/docs/quickstart.html

gitta needs Git for Windows. Its hooks and gate commands run in the sh that Git for Windows installs. gitta update works on Windows too. Shared copy-on-write workspaces and the agent sandbox are Linux only, and inside WSL you can use the install script as on Linux.

You can also download the zip for your processor from the latest release, check it with Get-FileHash -Algorithm SHA256 against the .sha256 file next to it, and put gitta.exe in a folder on your PATH.

Build from source

Use a recent stable Rust toolchain. This works on every platform in the table above.

$ git clone https://github.com/gitta-io/gitta
$ cd gitta
$ cargo install --path gitta-cli

Check the download

Each release publishes a checksum for every build, and an SBOM and a CBOM. See SBOM and CBOM.

Update

If you installed gitta with the install script, let gitta update itself.

$ gitta update

gitta update asks gitta.io for the latest release, downloads the build for your system and verifies its SHA-256 checksum. If gitta.io does not answer, it gets the release from GitHub. Then it writes the new files next to the current gitta and renames them over the old ones, so a running gitta is never changed in place. To see if a new release exists without installing it, add --check.

$ gitta update --check

If Homebrew installed gitta, update it with Homebrew.

$ brew upgrade gitta

If you built gitta with cargo install, run that command again. In both cases gitta update leaves the installation as it is and prints the command to use.

Repositories that use gitta need no change. Their settings stay in each repository's .gitta/ folder.

Update notice

When a newer release exists, gitta prints one line about it, at most once a day. The check runs in the background with a short timeout, so commands do not wait for it. It sends the gitta version, your operating system and your CPU type to gitta.io, and asks GitHub when gitta.io is out of reach. The result is kept in your user cache folder.

The notice shows only at a terminal. It stays out of CI, agent hooks, the MCP server and JSON output. To turn it off, do one of these:

• Set GITTA_NO_UPDATE_CHECK=1 in your environment.
• Put {"update_check": false} in ~/.config/gitta/config.json.

Coming next

Release builds for FreeBSD come next. With gitta Enterprise, gitta also runs inside z/OS in a zCX container, see the Mainframe guide.

Next step

Continue with the quick start.