How to Install tinyhumansai/openhuman: Complete Setup Guide for macOS, Linux, and Windows

Run brew tap tinyhumansai/core && brew install openhuman on macOS, use the APT repository on Debian/Ubuntu, or execute curl -fsSL https://raw.githubusercontent.com/tinyhumansai/openhuman/main/scripts/install.sh | bash for a quick scripted installation across platforms.

The tinyhumansai/openhuman repository provides a cross-platform AI assistant composed of a Rust core (src/) and a React-Tauri desktop interface (app/). Installation is platform-aware, offering native package managers for macOS, Linux distributions, and Windows alongside a universal shell script that downloads the latest release directly from GitHub. This guide covers all supported installation methods, critical file paths, and post-install verification steps.

Native Package Installation (Recommended)

Native packages provide the strongest integrity guarantees through OS-level signing chains. The project maintains official repositories for major platforms.

macOS via Homebrew

The Homebrew tap provides a signed bottle for both Intel and Apple Silicon Macs.

brew tap tinyhumansai/core
brew install openhuman

Verify the installation by checking the version:

openhuman --version

Debian/Ubuntu via APT

Add the official repository and install using the following commands. The GPG key is stored in /etc/apt/keyrings/openhuman.gpg as per the repository configuration.

sudo apt-get install -y --no-install-recommends gnupg2 curl ca-certificates
curl -fsSL https://tinyhumansai.github.io/openhuman/apt/KEY.gpg | sudo gpg --dearmor -o /etc/apt/keyrings/openhuman.gpg
echo "deb [signed-by=/etc/apt/keyrings/openhuman.gpg arch=amd64] https://tinyhumansai.github.io/openhuman/apt stable main" | sudo tee /etc/apt/sources.list.d/openhuman.list
sudo apt-get update
sudo apt-get install -y openhuman

Arch Linux via AUR

Install the binary package from the Arch User Repository using your preferred AUR helper:

yay -S openhuman-bin

Windows via MSI

Download the signed .msi installer from the latest release page and run the installer. The MSI places the binary in the system PATH and registers the application with Windows.

Scripted Installer (Quick Start)

For platforms without native packages or for testing bleeding-edge builds, use the scripts/install.sh script. This method downloads the latest release asset directly from GitHub and validates the SHA-256 digest when available.

curl -fsSL https://raw.githubusercontent.com/tinyhumansai/openhuman/main/scripts/install.sh | bash

How the Script Works

The installer script performs these actions as implemented in scripts/install.sh:

1. Detects the operating system (darwin or linux) and architecture (x86_64 or aarch64)
2. Resolves the latest release URL via latest.json or falls back to the GitHub releases API
3. Downloads the appropriate AppImage (Linux) or .app bundle (macOS)
4. Installs the binary to ~/.local/bin/openhuman on Linux or copies the app to ~/Applications on macOS
5. Adds ~/.local/bin to the user's $PATH if not already present
6. Creates a desktop entry file on Linux for GUI launching

Available Flags

You can pass flags to the script using bash -s --:

Flag	Effect
--dry-run	Prints actions without touching the filesystem
--channel stable	Targets the stable release channel (default)
--verbose	Enables detailed logging of download and extraction steps

Example dry-run command:

curl -fsSL https://raw.githubusercontent.com/tinyhumansai/openhuman/main/scripts/install.sh | bash -s -- --dry-run

Post-Installation Verification

After installation, verify the binary is accessible and the core RPC server can start. The Rust core implements a JSON-RPC server in src/rpc/mod.rs that the Tauri UI communicates with over a local loopback socket.

Test the CLI:

openhuman --help

Start the core server manually:

openhuman serve

On macOS, launch the desktop application directly:

open ~/Applications/OpenHuman.app

The desktop UI (app/src-tauri/src/main.rs) automatically spawns the Rust core in-process, displaying the mascot and onboarding flow on first launch.

Architecture and File Locations

Understanding the installation layout helps with troubleshooting. According to AGENTS.md and the architecture documentation in gitbooks/developing/architecture.md:

• Core Binary: Located at ~/.local/bin/openhuman (scripted install) or system paths (package managers)
• Memory Tree: Persistent state stores in ~/.openhuman/ created on first run
• Security Policy: Runtime enforcement happens in src/openhuman/config/schema/autonomy.rs with no additional configuration required for default installations
• Manifest: The root Cargo.toml defines the Rust core crate dependencies

The Tauri desktop application bridges to the Rust core via JSON-RPC, meaning the installer only needs to place the compiled binary on the PATH or install the .app bundle; the UI handles core process management automatically.

Summary

• Native packages (Homebrew, APT, AUR, MSI) provide cryptographically verified installations through OS package managers
• Scripted installation via scripts/install.sh offers a universal one-liner for macOS and Linux with --dry-run support for safety
• Binary location defaults to ~/.local/bin/openhuman for scripted installs and system paths for package managers
• Data directory ~/.openhuman/ stores the memory tree and persistent state, created automatically on first run
• Verification requires running openhuman --help or openhuman serve to confirm the RPC core starts correctly

Frequently Asked Questions

What are the system requirements for tinyhumansai/openhuman?

The application requires a 64-bit operating system (macOS 11+, Ubuntu 20.04+, Windows 10+) with support for x86_64 or aarch64 architectures. The Rust core compiles against standard system libraries, while the Tauri-based UI requires a graphics environment capable of running WebKit. No additional runtime dependencies are needed for the packaged releases.

Where is the openhuman binary installed when using the script?

The scripts/install.sh script places the binary at ~/.local/bin/openhuman on Linux systems and the .app bundle at ~/Applications/OpenHuman.app on macOS. The script automatically appends ~/.local/bin to your shell profile if it is not already in the PATH. System-wide installations via APT or Homebrew place binaries in standard locations like /usr/local/bin or /usr/bin.

How do I uninstall tinyhumansai/openhuman?

For Homebrew installations, run brew uninstall openhuman and brew untap tinyhumansai/core. For APT, use sudo apt-get remove openhuman and remove the source list from /etc/apt/sources.list.d/. For scripted installs, remove ~/.local/bin/openhuman and the desktop entry from ~/.local/share/applications/. Delete the data directory ~/.openhuman/ to remove all persistent state and memory trees.

Does the desktop UI require separate installation?

No. The desktop UI and Rust core are bundled together. When installing via the scripted installer or native packages, you receive both the openhuman CLI binary and the Tauri-based GUI application. The UI (app/src-tauri/src/main.rs) spawns the core logic in-process via JSON-RPC, so launching the desktop app automatically starts the backend without requiring manual execution of openhuman serve.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}