---
title: Installation
description: Install the kobe CLI.
---

# Installation

The `kobe` CLI is a self-contained binary. It talks to a kobe operator endpoint. To install the operator itself, see [Deploy](/docs/getting-started/deploy).

All release binaries are signed (macOS codesigned and notarized, Windows code-signed, Linux/apt PGP-signed via GCP-KMS).

<Tabs items={["mise (recommended)", "Homebrew", "apt (Debian/Ubuntu)", "winget (Windows)", "Scoop (Windows)", "Chocolatey (Windows)", "AUR (Arch Linux)", "cargo", "Nix", "from source"]}>
  <Tab value="mise (recommended)">
    [mise](https://mise.jdx.dev) downloads the pre-built binary from GitHub releases and pins the version per project or globally.

    ```sh
    # install globally
    mise use -g github:kunobi-ninja/kobe@latest
    ```

    To pin a version in your project so every contributor gets the same binary:

    ```toml title="mise.toml"
    [tools]
    "github:kunobi-ninja/kobe" = "latest"
    ```

    Running `mise install` in the project root installs the pinned version.
  </Tab>
  <Tab value="Homebrew">
    macOS and Linux, via the Kunobi tap:

    ```sh
    brew install kunobi-ninja/kunobi/kobe
    ```

    Pre-release (RC/beta) builds are a separate formula:

    ```sh
    brew install kunobi-ninja/kunobi/kobe-unstable
    ```
  </Tab>
  <Tab value="apt (Debian/Ubuntu)">
    Add the signed Kunobi apt repository (served from Cloudflare R2) and install.
    The published `gpg.key` is an ASCII-armored OpenPGP cert, so it must be
    dearmored into the binary keyring apt expects:

    ```sh
    sudo mkdir -p /etc/apt/keyrings
    curl -fsSL https://r2.kunobi.com/kobe/apt/gpg.key \
      | sudo gpg --dearmor -o /etc/apt/keyrings/kobe.gpg
    echo "deb [signed-by=/etc/apt/keyrings/kobe.gpg] https://r2.kunobi.com/kobe/apt stable main" \
      | sudo tee /etc/apt/sources.list.d/kobe.list
    sudo apt-get update && sudo apt-get install kobe
    ```

    Use the `unstable` suite instead of `stable` for pre-release builds.
  </Tab>
  <Tab value="winget (Windows)">
    ```powershell
    winget install kunobi-ninja.kobe
    ```

    Pre-release builds: `winget install kunobi-ninja.kobe.Unstable`.
  </Tab>
  <Tab value="Scoop (Windows)">
    Add the Kunobi bucket once, then install from it:

    ```powershell
    scoop bucket add kunobi https://github.com/kunobi-ninja/scoop-kunobi

    # Stable
    scoop install kunobi/kobe

    # Pre-release channel
    scoop install kunobi/kobe-unstable
    ```
  </Tab>
  <Tab value="Chocolatey (Windows)">
    ```powershell
    choco install kobe
    ```

    Pre-release builds: `choco install kobe --pre`.
  </Tab>
  <Tab value="AUR (Arch Linux)">
    Three official packages are available (all provide the `kobe` command — install one):

    ```sh
    # Prebuilt binary — recommended (statically linked, x86_64 + aarch64, no compile)
    paru -S kobe-bin

    # Builds the latest main from source
    paru -S kobe-git

    # Builds the latest release from source
    paru -S kobe
    ```
  </Tab>
  <Tab value="cargo">
    The CLI is published to crates.io as `kobectl` (the crate name `kobe` was taken; the installed binary is still `kobe`).

    ```sh
    # download a pre-built binary (no compile) via cargo-binstall
    cargo binstall kobectl

    # or compile from crates.io
    cargo install kobectl
    ```
  </Tab>
  <Tab value="Nix">
    Run without installing, or add to a profile:

    ```sh
    nix run github:kunobi-ninja/kobe -- --help
    nix profile install github:kunobi-ninja/kobe
    ```
  </Tab>
  <Tab value="from source">
    ```sh
    cargo install --git https://github.com/kunobi-ninja/kobe --bin kobe
    ```

    This compiles the CLI only. Rust 1.94.1 or later is required (`Cargo.toml` `rust-version`).
  </Tab>
</Tabs>

## Verify the installation

```sh
kobe --help
```

You should see the commands grouped by task. If the command is not found, put the binary on your `PATH`.

## Shell completions

`kobe completions <shell>` prints a completion script for `bash`, `zsh`, `fish`, `elvish`, or `powershell`. Load it from your shell's startup file:

```sh
source <(kobe completions zsh)          # ~/.zshrc
source <(kobe completions bash)         # ~/.bashrc
kobe completions fish | source          # ~/.config/fish/config.fish
```

Next: [point the CLI at an endpoint](/docs/getting-started/quick-start), or [deploy the operator](/docs/getting-started/deploy) if you are standing kobe up yourself.