Tutoriel : votre premier fichier dans Turbo Rust

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205

# Tutoriel : votre premier fichier dans Turbo Rust

À la fin de ce tutoriel, vous aurez construit l'éditeur, écrit un petit programme Rust à l'intérieur, vu les mots-clés changer de couleur pendant que vous tapiez, enregistré le fichier et exécuté le programme. Cela prend une dizaine de minutes.

Aucune connaissance préalable de Turbo Rust n'est nécessaire. Il vous faut Go 1.26 ou plus récent pour construire l'éditeur, et Rust pour exécuter ce que vous écrirez dedans.

## Prérequis

Vérifiez que Go est là — l'éditeur est écrit en Go, même si c'est un éditeur pour Rust :

```bash
go version
```

Vous devriez voir quelque chose comme :

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

Si cette commande échoue, installez d'abord Go : https://go.dev/dl/

Vérifiez que Rust est là aussi :

```bash
cargo --version
```

Vous devriez voir quelque chose comme :

```
cargo 1.97.1 (8bab26f4f 2026-07-14)
```

Si cette commande échoue, installez Rust depuis https://rustup.rs

## Étape 1 — Construire l'éditeur

Depuis le répertoire du projet, tapez :

```bash
make build
```

Vous devriez voir une ligne `go build`, puis plus rien. Le silence est un succès : Go ne dit rien quand une construction fonctionne.

Nous avons maintenant un exécutable dans `bin/turbo-rust`. Retenez où il est, pour pouvoir le lancer de n'importe où :

```bash
export TURBO="$PWD/bin/turbo-rust"
```

## Étape 2 — Créer un endroit où travailler

Turbo Rust est à son meilleur à l'intérieur d'une caisse, alors créons-en une :

```bash
cd /tmp && cargo new hello && cd hello
```

Vous devriez voir :

```
    Creating binary (application) `hello` package
```

`cargo new` écrit un `Cargo.toml` et un `src/main.rs` contenant un hello-world. Nous allons remplacer le contenu de ce fichier par le nôtre.

## Étape 3 — Ouvrir l'éditeur

Lancez Turbo Rust sur le fichier que cargo vient de créer :

```bash
$TURBO src/main.rs
```

L'écran se remplit d'un bureau bleu. Vous devriez voir :

- une **barre de menus** en haut : `File  Edit  Search  Run  Code  Options  Window  Snippets  Rust  Help`
- une **fenêtre** encadrée d'un double trait, intitulée `main.rs`
- une **barre d'état** en bas : `F1 Describe  F2 Save  F3 Open …`

Le curseur clignote à la ligne 1, colonne 1 — la barre d'état affiche `1:1` à droite.

Nous sommes dans l'éditeur.

## Étape 4 — Vider le fichier et taper un programme Rust

Appuyez sur **Ctrl-A** pour tout sélectionner, puis sur **Suppr** pour effacer ce que cargo avait écrit. La fenêtre est vide et son titre affiche `main.rs *` — l'étoile signifie qu'il y a des modifications non enregistrées.

Tapez ces deux lignes, en appuyant sur Entrée à la fin de chacune :

```rust
fn main() {
    let name = "Turbo Rust";
```

Regardez les couleurs pendant que vous tapez. `fn` et `let` deviennent **blanc et gras** dès que le mot se termine : ce sont des mots-clés. `main` devient **jaune et gras** dès que vous tapez le `(` qui suit, parce que cela en fait une fonction. `"Turbo Rust"` devient **vert** : c'est une chaîne.

(Ce sont les couleurs de Turbo Classic, celles dans lesquelles l'éditeur démarre. L'étape 8 les change.)

Appuyez sur **Entrée**. Regardez la nouvelle ligne : le curseur est *déjà* indenté comme la ligne précédente. Turbo Rust a recopié l'indentation, ce qui est ce que l'on veut neuf fois sur dix.

Tapez la ligne suivante :

```rust
println!("Hello from {name}!");
```

`println!` devient **cyan et gras**, le `!` compris : une macro est un seul nom, et colorer le `!` à part le ferait lire comme une négation.

> Quand vous tapez le `.` après un nom, la barre d'état affiche brièvement un message sur le serveur de langage. C'est normal : la complétion a besoin de `rust-analyzer`, que nous n'avons pas installé. Le [guide de la complétion](../how-to/enable-completion.md) s'en occupe plus tard ; ignorez-le pour l'instant.

Appuyez sur **Entrée**, puis sur **Maj-Tab** pour retirer l'indentation, puis tapez l'accolade fermante :

```rust
}
```

Nous venons d'écrire un programme Rust complet, l'éditeur le colorant au fur et à mesure.

## Étape 5 — L'enregistrer

Appuyez sur **F2**.

L'étoile disparaît du titre, et la barre d'état affiche :

```
Saved src/main.rs
```

Nous venons d'écrire le fichier sur le disque.

## Étape 6 — Regarder le fichier de l'extérieur

Quittez l'éditeur avec **Alt-X**. Le terminal revient comme il était.

Vérifiez ce que nous avons écrit :

```bash
cat src/main.rs
```

Vous devriez voir :

```rust
fn main() {
    let name = "Turbo Rust";
    println!("Hello from {name}!");
}
```

## Étape 7 — L'exécuter

```bash
cargo run
```

Vous devriez voir, après une ligne ou deux de cargo :

```
Hello from Turbo Rust!
```

C'est un programme Rust qui fonctionne, écrit entièrement dans l'éditeur.

## Étape 8 — Changer de thème

Rouvrez le fichier :

```bash
$TURBO src/main.rs
```

Appuyez sur **F10**. Le menu `File` s'ouvre. Appuyez cinq fois sur **→** : le menu se déplace le long de la barre jusqu'à `Options`, dont le premier élément, `Theme…`, est mis en évidence. Appuyez sur **Entrée**.

Une liste de onze apparaît, par ordre alphabétique, le thème que vous utilisez étant déjà mis en évidence :

```
borland-light
cappuccino
catppuccin-frappe
catppuccin-latte
cobalt
darcula
intellij-light
monochrome-dark
monochrome-light
turbo-classic
turbo-dark
```

`turbo-classic` est la ligne en évidence, puisque c'est le thème dans lequel vous êtes. Appuyez une fois sur **↓** pour aller sur `turbo-dark`, puis sur **Entrée**.

Tout l'éditeur se repeint en gris foncé, et la barre d'état affiche `Theme: Turbo Dark`.

Appuyez sur **Alt-X** pour sortir.

## Et maintenant ?

Vous avez construit l'éditeur, écrit un programme Rust dedans, l'avez enregistré, exécuté, et vous en avez changé l'apparence.

- Pour faire des choses précises — activer la complétion, écrire votre propre thème, chercher dans un fichier → voir les [guides pratiques](../how-to/)
- Pour retrouver une touche ou une entrée de menu → voir la [référence](../reference/)
- Pour comprendre comment la coloration et la complétion fonctionnent vraiment → voir les [explications](../explanation/)