# How to install GoloScript

This guide shows how to get `golo` — and, if you want them, `gogolo` and `wagolo` — onto a machine, and how to check that Turbo Golo can find it. It assumes you already have Turbo Golo, or are about to — see [how to install the editor](install.md) for that.

**The editor works without any of this.** Editing, colouring, themes, snippets and terminal windows all run with no interpreter at all. What needs it is completion, the error marks in the gutter, and every command in the Golo menu.

## Which binary you need

GoloScript ships three, under one version:

| Binary | What it is for | Also needs |
| --- | --- | --- |
| `golo` | The interpreter: runs scripts, and is also the REPL, the debugger, the test runner and **the language server** | nothing |
| `gogolo` | Compiles a script to a native executable, through Go | the Go toolchain |
| `wagolo` | Compiles a script to WebAssembly, through Go and TinyGo | TinyGo, and `wasm-tools` for the `wasip2` target |

The editor needs `golo` and nothing else. `gogolo` and `wagolo` are what the **Build native** and **Build wasm** items in the Golo menu run; without them those two items report `command not found` and the rest of the menu is unaffected.

## Install a release

Precompiled binaries for macOS (Intel and Apple Silicon), Linux (amd64, arm64, 386) and Windows (amd64, arm64, 386) are on the [releases page](https://codeberg.org/TypeUnsafe/golo-script/releases). Each is one file:

```bash
chmod +x golo-<version>-<platform>
sudo mv golo-<version>-<platform> /usr/local/bin/golo
golo --version
```

On macOS an unsigned download is quarantined until you say otherwise, in **System Settings ▸ Privacy & Security** or with `xattr -d com.apple.quarantine golo-<version>-<platform>`.

Repeat for `gogolo` and `wagolo` if you want the compilers.

## Or build from source

This gives you all three at once, into `/usr/local/bin`. It needs Go; `wagolo` builds without TinyGo but cannot compile anything until TinyGo is installed.

```bash
git clone https://codeberg.org/TypeUnsafe/golo-script.git && cd golo-script
./install.sh
```

Turbo Golo's own installer will do exactly that when asked:

```bash
scripts/install.sh --with-server
```

It clones GoloScript into a temporary directory and runs its `install.sh`, which asks for `sudo` when it copies into `/usr/local/bin`.

## Check it

```bash
golo --version
```

```
v0.1.1 | dev.20260802.🤓
```

And the language server specifically — it is the interpreter, so this is a subcommand rather than a second binary:

```bash
golo lsp </dev/null
```

It reads nothing, sees the end of its input, and exits cleanly. A `golo` that prints its usage or starts a REPL here is a different program with the same name.

## Check that the editor finds it

Open any `.golo` file and read the right-hand end of the status bar:

```
 F1 Describe  F2 Save  F3 Open  F6 Window  F10 Menu       1:1  LSP: ready
```

`LSP: ready` means the server started. `LSP: no golo — see https://codeberg.org/TypeUnsafe/golo-script/releases` means it was not found, and the message says where to get it.

**Turbo Golo looks in two places, in order**: your `PATH`, then `/usr/local/bin`. The second is where GoloScript's installer writes, and it is searched even when it is not on `PATH` — a shell started by a desktop launcher, say — so that the case that otherwise looks like the server being broken works.

## Variants

- **You install binaries somewhere else.** Put that directory on `PATH`; the editor has no environment variable naming another place to look. A symbolic link in `/usr/local/bin` also works.
- **You already have `golo` but no completion.** Run `golo lsp </dev/null` and make sure it exits quietly. Then read the status bar — `Run ▸ Language server status` shows the path the editor found and whether the server answered its handshake.
- **You want to upgrade.** Replace the binary — a release download or `./install.sh` again from a fresh `git pull`. Restart the editor: it starts one server per session and does not notice a new binary until then.
- **You are installing for CI, or into an image.** GoloScript publishes a `scratch`-based image holding the interpreter alone: `docker run --rm -v "$PWD:/app" -w /app k33g/gololang:<tag> /golo ./main.golo`. The editor cannot use a server inside a container, so this is for running scripts, not for completion.
- **You want to be sure the editor is not simply finding it on `PATH`.** Start it with a stripped environment — `env PATH=/usr/bin:/bin turbo-golo main.golo` — and the status bar should still say `LSP: ready`, from `/usr/local/bin`.

## What each binary is for, from the editor's side

| Binary | What the editor uses it for |
| --- | --- |
| `golo` | `golo lsp` — completion, hover, definitions, the file's symbols and the error marks; and the **Run**, **Test**, **Test one**, **Debug**, **REPL** and **New script** items of the Golo menu |
| `gogolo` | The **Build native** item |
| `wagolo` | The **Build wasm** item |

## See also

- [How to enable completion](enable-completion.md) — what to do when the server is installed and still says nothing
- [How to run Golo commands from the editor](run-golo-commands.md) — the Golo menu
- [Colouring and completion](../explanation/colouring-and-completion.md) — why the interpreter is the server