# What versions of Go does Goose support?

> Goose is written in Rust and supports any Go version when interacting via CLI or HTTP API. Learn how to use Goose with your Go projects.

- Repository: [goose/goose](https://github.com/aaif-goose/goose)
- Tags: faq
- Published: 2026-04-07

---

**Goose does not require, support, or depend on any specific Go version because the project is implemented entirely in Rust**, though you can interact with the AI agent from Go applications via its CLI or HTTP API endpoints.

The `aaif-goose/goose` repository is an AI agent framework and desktop application built primarily in Rust, not Go. Despite its name suggesting a potential connection to the Go programming language (often called Golang), the codebase contains no Go source files, version constraints, or Go module definitions.

## Why Goose has no Go version requirements

Goose is a Rust-centric project. The source code resides under the `crates/` directory with standard Rust project files ([`Cargo.toml`](https://github.com/aaif-goose/goose/blob/main/Cargo.toml), `Cargo.lock`), and the build system relies entirely on Cargo.

- **No Go source files**: The repository contains no `go.mod`, `go.sum`, or `*.go` files that would indicate Go language support or version constraints.
- **Rust toolchain only**: Continuous integration workflows in `.github/workflows/*.yml` configure Rust toolchains (specifically Rust 1.78+ as of the current CI configuration) via `dtolnay/rust-toolchain`, with no references to Go versions or the Go toolchain.
- **Generic tool reference**: The only mention of Go appears in [`recipe-scanner/base_recipe.yaml`](https://github.com/aaif-goose/goose/blob/main/recipe-scanner/base_recipe.yaml), which lists `go get` as a generic development tool for fetching modules. This is unrelated to Goose's own compilation or runtime requirements.

## How to integrate Goose with Go applications

While Goose itself requires no Go version, you can invoke it from Go projects using two primary integration patterns.

### Executing the Goose CLI from Go

Since Goose installs as a binary (`goose`) and a desktop application (`goose-desktop`), you can execute it from Go using standard library process execution.

```go
package main

import (
    "os"
    "os/exec"
)

func runGoose(prompt string) error {
    cmd := exec.Command("goose", "run", prompt)
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr
    return cmd.Run()
}

```

Your Go version has no impact on Goose's execution; any modern Go release capable of `os/exec` operations will suffice.

### Using the MCP HTTP API

Goose exposes functionality via the Model Context Protocol (MCP) HTTP server. You can interact with this API from Go using standard HTTP clients without version constraints.

```go
package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

func queryGooseServer(endpoint string, payload map[string]interface{}) (*http.Response, error) {
    jsonData, _ := json.Marshal(payload)
    return http.Post(endpoint, "application/json", bytes.NewBuffer(jsonData))
}

```

## Actual system requirements for Goose

To build or run Goose from source, you need the Rust toolchain rather than Go.

- **Rust 1.78+**: As specified in the project's CI workflows and Cargo configuration, Goose requires Rust version 1.78 or newer to compile the `crates/` workspace.
- **Cargo**: The build and dependency management rely on Cargo commands (`cargo build`, `cargo run`), not `go build` or Go modules.

## Summary

- Goose contains **no Go code** and therefore defines **no supported Go versions**.
- The project is a **Rust codebase** requiring **Rust 1.78+** to build from source.
- You can invoke Goose from **any Go version** via CLI execution or HTTP API calls to the MCP server.
- The only Go reference in the repository is a generic tool mention in [`recipe-scanner/base_recipe.yaml`](https://github.com/aaif-goose/goose/blob/main/recipe-scanner/base_recipe.yaml).

## Frequently Asked Questions

### Is Goose written in Go?

No. Goose is written in **Rust**, with source code organized under the `crates/` directory. The project uses Cargo for builds and dependency management, not Go modules.

### Can I use Goose with my Go application?

Yes. While Goose is not written in Go, you can integrate it into Go applications by executing the `goose` CLI binary via `os/exec` or by making HTTP requests to Goose's MCP server endpoint. The Go version you use in your application does not affect Goose's operation.

### What programming language is Goose built with?

Goose is built with **Rust**. The repository includes [`Cargo.toml`](https://github.com/aaif-goose/goose/blob/main/Cargo.toml) files and Rust source files within the `crates/` directory, requiring the Rust toolchain (version 1.78+) for compilation.

### Do I need to install Go to build Goose from source?

No. Building Goose from source requires only the **Rust toolchain** (Rust 1.78+ and Cargo). Go is not required for compilation, development, or running the Goose binary.