Installation

This page covers every install path plus post-install configuration. For the fastest path (pre-built binary + setup wizard), see the Quick start on the project README.

Requirements

• Go 1.25+ for building from source
• A modern terminal for the interactive TUI
• A model provider: Ollama, OpenAI, Anthropic, Gemini, xAI, ChatGPT OAuth through openai-auth, GitHub Copilot through copilot-auth, or any OpenAI-compatible /v1 API

Installer script (recommended)

curl -fsSL https://yottacode.ai/cli/install.sh | bash

The script detects your OS/arch (Linux + macOS, amd64 + arm64), resolves the latest GitHub release (or honors VERSION=0.4.0 if set), verifies the archive against SHA256SUMS, and installs to $HOME/.yottacode/bin/yottacode. No sudo required. It then offers to append a PATH export to your shell rc file (zsh / bash / fish / sh detected from $SHELL), backing up the rc first.

Useful flags and env:

• VERSION=0.4.0 — pin a version instead of “latest”.
• INSTALL_DIR=/custom/path — override the install location.
• --no-modify-rc — skip the rc-file edit (useful when you manage PATH yourself).
• --yes / -y — non-interactive: assume “yes” to prompts (required in CI).
• NO_COLOR=1 — disable ANSI colors and animations.

Re-running the installer upgrades in place: same flow, the rc edit is detected and skipped via sentinel comments.

Homebrew

brew install yottadynamics/yottacode/yottacode

That taps yottadynamics/homebrew-yottacode on first use and installs the latest stable release binary for your CPU (macOS Apple silicon and Intel). It is a Homebrew formula: Homebrew downloads the same release archive the installer script uses and checks its pinned SHA-256; it never builds from source or from main. The binary is linked into Homebrew’s PATH ($(brew --prefix)/bin), so no rc-file edit is needed.

Tap contents are generated as a formula under Formula/yottacode.rb. The release workflow validates the generated archive matrix and updates the tap only for stable tags.

On Linux, use the installer script above.

Equivalent two-step form:

brew tap yottadynamics/yottacode
brew install yottacode

Upgrade and remove with the usual commands:

brew upgrade yottacode
brew uninstall yottacode

Only stable releases reach the tap. Pre-release tags such as v0.5.0-rc.2 are GitHub prereleases only; use the installer script with VERSION= to try one. Uninstalling leaves ~/.yottacode (config, memory, sessions) in place.

Pick one install method per machine. The installer script keeps its own copy in $HOME/.yottacode/bin, and whichever directory comes first on PATH wins.

Updating

yottacode checks GitHub for a newer release once per day on TUI startup. The check runs in the background after the TUI starts, is cached at ~/.yottacode/cache/update-check.json, and runs only when the root interactive command launches into a real terminal — yottacode run, yottacode --version, scripts, and pipes never trigger it. GitHub, DNS, or network slowness never blocks first paint. When a newer release exists, you’ll see a one-line in-session notice:

⚠ update · new release · 0.4.0 available · current 0.3.0 · https://github.com/yottadynamics/yottacode/releases/tag/v0.4.0

To upgrade, re-run the installer, run brew upgrade yottacode if you installed with Homebrew (the tap picks up a new stable release shortly after it is tagged), or download the new release from the linked release notes.

To disable the check entirely (CI, privacy, sandboxes): export YOTTACODE_NO_UPDATE_CHECK=1. To force a refresh: rm ~/.yottacode/cache/update-check.json.

Manual binary install

VERSION=0.4.0
# Swap linux/darwin and amd64/arm64 to match your machine
curl -fsSL https://github.com/yottadynamics/yottacode/releases/download/v${VERSION}/yottacode_${VERSION}_linux_amd64.tar.gz \
  | tar -xz
install -m 0755 ./yottacode "$HOME/.yottacode/bin/yottacode"

Build from source

git clone https://github.com/yottadynamics/yottacode.git
cd yottacode
go build -o yottacode ./cmd/yottacode

Run it from the repo:

./yottacode --help

Install it onto your PATH:

sudo install -m 0755 ./yottacode /usr/local/bin/yottacode

Or install into a user-local bin directory:

mkdir -p ~/.local/bin
install -m 0755 ./yottacode ~/.local/bin/yottacode

Make sure ~/.local/bin is on your PATH.

Go install from a local checkout

From the repository root:

go install ./cmd/yottacode

This writes the binary to $(go env GOPATH)/bin.

Cross-compile

GOOS=darwin GOARCH=arm64 go build -o yottacode-darwin-arm64 ./cmd/yottacode
GOOS=darwin GOARCH=amd64 go build -o yottacode-darwin-amd64 ./cmd/yottacode
GOOS=linux  GOARCH=arm64 go build -o yottacode-linux-arm64  ./cmd/yottacode
GOOS=linux  GOARCH=amd64 go build -o yottacode-linux-amd64  ./cmd/yottacode

Supported platforms

• Linux: supported by source builds and release binaries
• macOS: supported by source builds and release binaries
• Windows: not a release target; run yottacode under WSL

Sandbox image packages

The optional Podman command sandbox pulls two GHCR images when enabled:

• ghcr.io/yottadynamics/yottacode-sandbox:latest for run_bash and run_tests
• ghcr.io/yottadynamics/yottacode-documents:latest for document subprocess helpers

Published releases also tag both images with the release tag (for example ghcr.io/yottadynamics/yottacode-sandbox:v0.4.0) plus a UTC date tag. If a pull returns 401 or not found, the image package is private or not linked for anonymous pulls; the image workflows verify anonymous pulls after publish so that misconfiguration fails CI.

Run the setup wizard (recommended)

yottacode does not guess a default model or endpoint. The fastest post-install path is the interactive wizard:

yottacode setup

The wizard writes ~/.yottacode/config.toml and ~/.yottacode/.env, probes providers where possible, and can be rerun later with /setup from inside the TUI. Before writing, it shows a review panel with the destination paths, active provider/model, optional router/search settings, and explicit Write config, Back, and Abort actions.

Or configure manually

You need a model id, a base URL, and (for some providers) an API key. Each provider has its own page with both TUI and command-line setup; here are three common command-line examples.

Local Ollama — no API key, run a model locally:

ollama serve
ollama pull <your-model-id>

export YOTTACODE_PROVIDER=ollama
export YOTTACODE_MODEL=<your-model-id>
export YOTTACODE_BASE_URL=http://localhost:11434/v1

yottacode

ChatGPT OAuth — use your ChatGPT account via OAuth:

yottacode openai-auth login

export YOTTACODE_PROVIDER=openai-auth
export YOTTACODE_MODEL=<your-model-id>     # /model list shows what your account allows
export YOTTACODE_BASE_URL=https://chatgpt.com/backend-api/codex

yottacode

openai-auth stores tokens under ~/.yottacode/auth/ with restrictive permissions; that directory is blocked from model reads and writes.

GitHub Copilot — bill against your GitHub Copilot subscription:

yottacode copilot-auth login

export YOTTACODE_PROVIDER=copilot
export YOTTACODE_MODEL=claude-haiku-4.5
export YOTTACODE_BASE_URL=https://api.githubcopilot.com

yottacode

copilot uses GitHub’s device code flow and bills against your Copilot subscription. Tokens and model cache live under ~/.yottacode/auth/.

Other OpenAI-compatible endpoints (NVIDIA NIM’s free tier, Groq, vLLM, …) work the same way — see Configuring providers.