# Tutoriel : votre premier programme Golo dans Turbo Golo

À la fin de ce tutoriel, vous aurez écrit, lancé et cassé un petit programme Golo sans quitter l'éditeur — et vu l'éditeur vous dire où était l'erreur.

Aucune connaissance préalable de Turbo Golo n'est nécessaire. Il vous faut Go 1.26 ou plus récent pour compiler l'éditeur, et l'interpréteur `golo` pour exécuter le programme.

## Prérequis

Vérifiez Go :

```bash
go version
```

Vous devriez voir quelque chose comme :

```
go version go1.26.5 linux/arm64
```

Vérifiez l'interpréteur :

```bash
golo --version
```

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

Si la commande est introuvable, installez-le d'abord — [un téléchargement ou un script suffit](../how-to/install-goloscript.md).

## Étape 1 — Installer l'éditeur

```bash
git clone https://rickub.com/turbo-editors/turbo-golo.git
cd turbo-golo
make install
```

L'installeur compile, installe, puis vérifie ce qu'il a installé. Les dernières lignes sont :

```
==> Checking the language server
  ✓ golo at /usr/local/bin/golo — completion comes from `golo lsp`

==> Ready
```

Nous avons maintenant une commande `turbo-golo`.

## Étape 2 — Créer un dossier

```bash
mkdir /tmp/hello
cd /tmp/hello
```

C'est là tout ce qu'il faut pour créer un projet Golo : Golo n'a pas de manifeste, un script est un fichier, et un programme est un dossier de fichiers. **Le dossier dans lequel vous démarrez l'éditeur** est celui où les commandes du menu Golo s'exécuteront, démarrez-le donc ici.

## Étape 3 — Ouvrir un fichier qui n'existe pas encore

```bash
turbo-golo hello.golo
```

L'écran se remplit. En haut :

```
 File  Edit  Search  Run  Code  Options  Window  Snippets  Golo  Help
```

Dix menus, et le neuvième porte le nom du langage. Au milieu, une fenêtre vide intitulée `hello.golo`. En bas, à droite, vous devriez voir :

```
1:1  LSP: ready
```

`LSP: ready` signifie que `golo lsp` — l'interpréteur, en mode serveur de langage — a démarré dans ce dossier. Nous nous en servirons à l'étape 8.

## Étape 4 — Écrire le programme

Tapez ceci. Tapez-le exactement ; nous allons regarder les couleurs juste après.

```golo
module hello.World

# Greet someone several times
struct Greeting = { name, times }

function greet = |g| {
  foreach i in range(1, g: times() + 1) {
    println("Hello, " + g: name() + "! (" + i + ")")
  }
}

function main = |args| {
  greet(Greeting("Golo", 3))
}
```

Si une liste de complétion s'ouvre pendant que vous tapez — un `.` en demande une de lui-même, et `hello.` en est un — continuez à taper ou appuyez sur `Échap` ; `Entrée` accepterait la première entrée.

Appuyez sur `F2` pour enregistrer. La barre d'état affiche `Saved hello.golo`.

## Étape 5 — Lire les couleurs

Regardez ce que vous venez de taper. Dans le thème par défaut `turbo-classic` :

| Quoi | Couleur |
| --- | --- |
| `module`, `struct`, `function`, `foreach`, `in` | blanc vif, gras — mots-clés |
| `hello.World`, `Greeting` | cyan vif — un chemin de module, et un type |
| `greet`, là où il est déclaré comme là où il est appelé | jaune vif, gras — fonctions |
| `range`, `println` | cyan vif, gras — des fonctions fournies par l'interpréteur |
| `name`, `times`, `g`, `i`, `args` | jaune vif — noms ordinaires |
| `"Hello, "`, `"! ("`, `")"`, `"Golo"` | vert — chaînes |
| `1`, `3` | magenta — nombres |
| `# Greet someone several times` | gris — un commentaire |
| `\|`, `:`, `+`, `=` | blanc — opérateurs |

Deux de ces lignes méritent un second regard.

**`Greeting` est cyan et `greet` est jaune**, et personne n'a dit à l'éditeur lequel des deux est un type. C'est la convention de Golo qui tranche : les structs, les unions et leurs variantes sont les noms que l'on écrit avec une majuscule, une majuscule est donc colorée comme un type.

**`greet` est jaune là où il est déclaré**, après `function`, bien qu'aucune parenthèse ne le suive à cet endroit. Le nom qui suit `function` est une fonction par sa position — [et c'est une règle délibérée](../explanation/colouring-and-completion.md).

## Étape 6 — Donner ses outils au projet

Appuyez sur `F10` pour ouvrir la barre de menus, puis sur `→` **huit fois** pour atteindre **Golo** — après Edit, Search, Run, Code, Options, Window et Snippets. Plus rapide : `Alt-G`.

Le menu contient deux entrées, et une seule est disponible :

```
┌───────────────────┐
│ Create tools file │
│ Open tools file   │   ← grisée ; il n'y a pas encore de fichier à ouvrir
└───────────────────┘
```

Choisissez **Create tools file**.

Une seconde fenêtre s'ouvre sur le fichier qui vient d'être écrit, `.turbo-golo/tools.toml`. Lisez-le si vous voulez — il explique chacune de ses clés — puis fermez-le avec `Ctrl-W`.

Regardez la barre de menus : un menu **Tools** est apparu entre Golo et Help. La dernière entrée du fichier de départ nomme un menu à elle, et cette seule ligne est tout le mécanisme.

Rouvrez le menu Golo. Il contient maintenant huit commandes, et les deux entrées ont échangé leurs rôles : `Create tools file` est grisée, et c'est `Open tools file` qui est choisissable.

## Étape 7 — Le lancer

Appuyez sur `Alt-G` et choisissez **Run**. Une boîte demande une valeur avant de lancer la commande, parce que Golo n'a pas de manifeste qui dise quel fichier est le programme :

```
┌──────────────── Run ────────────────┐
│  script, e.g. main.golo             │
│  [                               ]  │
└─────────────────────────────────────┘
```

Tapez `hello.golo` et appuyez sur `Entrée`. Une fenêtre de terminal s'ouvre et le programme s'y exécute :

```
Hello, Golo! (1)
Hello, Golo! (2)
Hello, Golo! (3)
```

Un terminal plutôt qu'une boîte de dialogue, parce qu'un programme qui lit le clavier doit pouvoir recevoir une réponse. Le programme est terminé, la fenêtre a donc cessé de se comporter comme un terminal et toutes les touches reviennent à l'éditeur : appuyez sur `Ctrl-W` pour la fermer.

## Étape 8 — Le casser, et voir où

Allez à la fin du fichier, après la dernière `}`, et ajoutez un commentaire comme un autre langage l'écrirait :

```golo
// run it
```

Appuyez sur `F2` pour enregistrer.

En moins d'une seconde, deux choses se produisent. Un `×` rouge apparaît dans la gouttière, juste à gauche du numéro de cette ligne. Et la barre d'état affiche :

```
⚠ GoloScript has no '//' line comments. GoloScript comments are '#' for a single line (e.g. …
```

Personne ne l'a demandé. `golo lsp` le publie de lui-même chaque fois qu'il relit le fichier — une erreur de syntaxe aurait valu la même marque, et celle-ci est un lint que le serveur ajoute parce que c'est la première erreur que fait quiconque arrive d'un autre langage.

Remplacez le `//` par `#` et enregistrez de nouveau ; la marque et le message disparaissent tous les deux.

## Étape 9 — Changer de thème

`F10`, puis `→` **cinq fois** pour atteindre **Options** — après Edit, Search, Run et Code. Choisissez **Theme…**.

Une liste s'ouvre sur le thème dans lequel vous êtes. Appuyez sur `↓` jusqu'à `cobalt` puis `Entrée`. Tout l'écran change, en gardant la même forme.

Appuyez sur `Alt-X` pour quitter. L'éditeur pose d'abord la question des fichiers non enregistrés, s'il y en a.

## Et maintenant ?

Vous avez écrit un programme Golo dans l'éditeur, l'avez lancé, cassé, et vu l'éditeur dire où. Pour aller plus loin :

- Pour faire des choses précises → les [guides pratiques](../how-to/)
- Pour savoir exactement ce qui est coloré et comment → [langages colorés](../reference/languages.md)
- Pour comprendre pourquoi l'éditeur est bâti ainsi → les [explications](../explanation/)