---
sidebar_position: 2
---

# CLI

Le CLI Wails a un certain nombre de commandes qui sont utilisées pour gérer vos projets. Toutes les commandes sont exécutées de la manière suivante:

`wails <commande> <options>`

## init

`wails init` est utilisé pour générer des projets.

| Option                    | Description                                                                                                            |  Par défaut   |
|:------------------------- |:---------------------------------------------------------------------------------------------------------------------- |:-------------:|
| -n "nom du projet"        | Nom du projet. **Obligatoire**.                                                                                        |               |
| -d "Répertoire du projet" | Dossier de projet à créer                                                                                              | Nom du projet |
| -g                        | Initialisation du dépôt git                                                                                            |               |
| -l                        | Liste des modèles de projet disponibles                                                                                |               |
| -q                        | Supprimer les logs dans la console                                                                                     |               |
| -t "nom du modèle"        | Modèle de projet à utiliser. Cela peut être le nom d'un modèle par défaut ou d'une URL d'un projet hébergé sur github. |    vanilla    |
| -ide                      | Générer les fichiers du projet IDE                                                                                     |               |
| -f                        | Forcer la compilation de l'application                                                                                 |     false     |

Exemple: `wails init -n test -d mytestproject -g -ide vscode -q`

Cela va générer un projet appelé "test" dans le répertoire "mytestproject", initialiser git, générer des fichiers de projet vscode et le faire silencieusement.

Plus d'informations sur l'utilisation des IDEs avec Wails peuvent être trouvées [ici](../guides/ides.mdx).

### Modèles à distance

Les modèles distants (hébergés sur GitHub) sont pris en charge et peuvent être installés en utilisant l'URL du projet du modèle.

Exemple : `wails init -n test -t https://github.com/leaanthony/testtemplate[@v1.0.0]`

Une liste de modèles gérés par la communauté peut être trouvée [ici](../community/templates.mdx)

:::warning Attention

**Le projet Wails n'entretient pas, n'est pas responsable ni responsable des modèles tiers !**

Si vous n'êtes pas sûr d'un modèle, inspectez les fichiers `package.json` et `wails.json` pour savoir quels scripts sont exécutés et quels paquets sont installés.

:::

## build

`wails build` est utilisé pour compiler votre projet vers un binaire prêt à la production.

| Option               | Description                                                                                                                                                                                                        | Par défaut                                                                                                                                                                                                            |
|:-------------------- |:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |:--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| -platform            | Construit pour les [plates-formes](../reference/cli.mdx#platforms) données (séparées par des virgules) par exemple. `windows/arm64`. Notez que si vous ne donnez pas l'architecture, `runtime.GOARCH` est utilisé. | platform = le contenu de la variable d'environnement `GOOS` si elle existe, autrement `runtime.GOOS`.<br/>arch = le contenu de la variable d'environnement `GOARCH` si elle existe, autrement `runtime.GOARCH`. |
| -clean               | Nettoie le répertoire `build/bin`                                                                                                                                                                                  |                                                                                                                                                                                                                       |
| -compiler "compiler" | Utiliser un autre compilateur pour compiler, par exemple go1.15beta1                                                                                                                                               | go                                                                                                                                                                                                                    |
| -ldflags "flags"     | Options supplémentaires à passer au compilateur                                                                                                                                                                    |                                                                                                                                                                                                                       |
| -nopackage           | Ne pas empaqueter l'application                                                                                                                                                                                    |                                                                                                                                                                                                                       |
| -o filename          | Nom du fichier de sortie                                                                                                                                                                                           |                                                                                                                                                                                                                       |
| -s                   | Ignorer la construction du frontend                                                                                                                                                                                | false                                                                                                                                                                                                                 |
| -f                   | Forcer la compilation de l'application                                                                                                                                                                             | false                                                                                                                                                                                                                 |
| -tags "extra tags"   | Options de compilation à passer au compilateur Go. Doivent être entre guillemets. Séparés par un espace ou une virgule (pas les deux)                                                                              |                                                                                                                                                                                                                       |
| -upx                 | Compresser le binaire final en utilisant "upx"                                                                                                                                                                     |                                                                                                                                                                                                                       |
| -upxflags            | Options à passer à upx                                                                                                                                                                                             |                                                                                                                                                                                                                       |
| -v int               | Niveau de verbosité (0 - silencieux, 1 - par défaut, 2 - verbeux)                                                                                                                                                  | 1                                                                                                                                                                                                                     |
| -webview2            | Stratégie d'installation WebView2 : download,embed,browser,error                                                                                                                                                   | download                                                                                                                                                                                                              |
| -u                   | Met à jour le `go.mod de votre projet` pour utiliser la même version de Wails que le CLI                                                                                                                           |                                                                                                                                                                                                                       |
| -debug               | Conserve les informations de débogage dans l'application. Permet l'utilisation des outils de développement dans la fenêtre de l'application                                                                        | false                                                                                                                                                                                                                 |
| -trimpath            | Supprimer tous les chemins vers les fichiers système de l'exécutable final.                                                                                                                                        | false                                                                                                                                                                                                                 |
| -race                | Construire avec le détecteur Go race                                                                                                                                                                               | false                                                                                                                                                                                                                 |
| -windowsconsole      | Garder la fenêtre de la console lors de la construction d'une version pour Windows                                                                                                                                 |                                                                                                                                                                                                                       |
| -obfuscate           | Cacher le code de l'application en utilisant [garble](https://github.com/burrowers/garble)                                                                                                                         | false                                                                                                                                                                                                                 |
| -garbleargs          | Arguments à passer à garble                                                                                                                                                                                        | `-literals -tiny -seed=random`                                                                                                                                                                                        |

Pour une description détaillée des options `webview2` , veuillez vous référer au Guide de [Windows](../guides/windows.mdx).

Si vous préférez construire en utilisant l'outil Go standard, veuillez consulter le guide [Constructions manuelles](../guides/manual-builds.mdx) .

Exemple:

`wails build -clean -o myproject.exe`

:::Info
Sur Mac, l'application sera livrée avec `Info.plist`, pas `Info.dev.plist`.
:::

:::info UPX sur Apple Silicon

Il y a [problèmes](https://github.com/upx/upx/issues/446) avec l'utilisation de UPX avec Apple Silicon.

:::

:::info UPX sur Windows

Certains antivirus marquent de manière erronée les binaires compressés d'`upx` comme virus, voir [la description du problème](https://github.com/upx/upx/issues/437).

:::

### Platformes

Plateformes supportées:

| Plateforme       | Description                                        |
|:---------------- |:-------------------------------------------------- |
| darwin           | MacOS + Architecture de la machine de construction |
| darwin/amd64     | MacOS 10.13+ AMD64                                 |
| darwin/arm64     | MacOS 11.0+ ARM64                                  |
| darwin/universal | Application universelle MacOS AMD64+ARM64          |
| windows          | Windows 10/11 + architecture de la machine         |
| windows/amd64    | Windows 10/11 AMD64                                |
| windows/arm64    | Windows 10/11 ARM64                                |
| linux            | Linux + architecture de la machine                 |
| linux/amd64      | Linux AMD64                                        |
| linux/arm64      | Linux ARM64                                        |

## doctor

`wails doctor` effectuera des diagnostics pour vous assurer que votre système est prêt pour développer avec wails.

Exemple:

```
Wails CLI v2.0.0-beta

Scanning system - Please wait (this may take a long time)...Done.

System
------
OS:             Windows 10 Pro
Version:        2009 (Build: 19043)
ID:             21H1
Go Version:     go1.18
Platform:       windows
Architecture:   amd64

Dependency      Package Name    Status          Version
----------      ------------    ------          -------
WebView2        N/A             Installed       93.0.961.52
npm             N/A             Installed       6.14.15
*upx            N/A             Installed       upx 3.96

* - Optional Dependency

Diagnosis
---------
Your system is ready for Wails development!

```

## dev

`wails dev` est utilisé pour exécuter votre application en mode « développement en direct ». Ceci signifie que :

- Le fichier `go.mod` de l'application sera mis à jour pour utiliser la même version de Wails que le CLI
- L'application est compilée et exécutée automatiquement
- A watcher is started and will trigger a rebuild of your dev app if it detects changes to your go files
- A webserver is started on `http://localhost:34115` which serves your application (not just frontend) over http. This allows you to use your favourite browser development extensions
- All application assets are loaded from disk. If they are changed, the application will automatically reload (not rebuild). All connected browsers will also reload
- A JS module is generated that provides the following:
  - JavaScript wrappers of your Go methods with autogenerated JSDoc, providing code hinting
  - TypeScript versions of your Go structs, that can be constructed and passed to your go methods
- A second JS module is generated that provides a wrapper + TS declaration for the runtime
- On macOS, it will bundle the application into a `.app` file and run it. It will use a `build/darwin/Info.dev.plist` for development.

| Option                       | Description                                                                                                                                                                         | Par défaut            |
|:---------------------------- |:----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |:--------------------- |
| -assetdir "./path/to/assets" | Serve assets from the given directory instead of using the provided asset FS                                                                                                        | Value in `wails.json` |
| -browser                     | Opens a browser to `http://localhost:34115` on startup                                                                                                                              |                       |
| -compiler "compiler"         | Utiliser un autre compilateur pour compiler, par exemple go1.15beta1                                                                                                                | go                    |
| -e                           | Extensions to trigger rebuilds (comma separated)                                                                                                                                    | go                    |
| -reloaddirs                  | Additional directories to trigger reloads (comma separated)                                                                                                                         | Value in `wails.json` |
| -ldflags "flags"             | Options supplémentaires à passer au compilateur                                                                                                                                     |                       |
| -tags "extra tags"           | Build tags to pass to compiler (quoted and space separated)                                                                                                                         |                       |
| -loglevel "loglevel"         | Loglevel to use - Trace, Debug, Info, Warning, Error                                                                                                                                | Debug                 |
| -noreload                    | Disable automatic reload when assets change                                                                                                                                         |                       |
| -nocolour                    | Turn off colour cli output                                                                                                                                                          | false                 |
| -nogen                       | Disable generate module                                                                                                                                                             |                       |
| -v                           | Verbosity level (0 - silent, 1 - standard, 2 - verbose)                                                                                                                             | 1                     |
| -wailsjsdir                  | The directory to generate the generated Wails JS modules                                                                                                                            | Value in `wails.json` |
| -debounce                    | The time to wait for reload after an asset change is detected                                                                                                                       | 100 (milliseconds)    |
| -devserver "host:port"       | The address to bind the wails dev server to                                                                                                                                         | "localhost:34115"     |
| -frontenddevserverurl "url"  | Use 3rd party dev server url to serve assets, EG Vite                                                                                                                               | ""                    |
| -appargs "args"              | Arguments passed to the application in shell style                                                                                                                                  |                       |
| -save                        | Saves the given `assetdir`, `reloaddirs`, `wailsjsdir`, `debounce`, `devserver` and `frontenddevserverurl` flags in `wails.json` to become the defaults for subsequent invocations. |                       |
| -race                        | Construire avec le détecteur Go race                                                                                                                                                | false                 |
| -s                           | Ignorer la construction du frontend                                                                                                                                                 | false                 |

Exemple:

`wails dev -assetdir ./frontend/dist -wailsjsdir ./frontend/src -browser`

This command will do the following:

- Build the application and run it (more details [here](../guides/manual-builds.mdx)
- Generate the Wails JS modules in `./frontend/src`
- Watch for updates to files in `./frontend/dist` and reload on any change
- Open a browser and connect to the application

There is more information on using this feature with existing framework scripts [here](../guides/application-development.mdx#live-reloading).

## generate

### template

Wails uses templates for project generation. The `wails generate template` command helps scaffold a template so that it may be used for generating projects.

| Option           | Description                                 |
|:---------------- |:------------------------------------------- |
| -name            | The template name (Mandatory)               |
| -frontend "path" | Path to frontend project to use in template |

For more details on creating templates, consult the [Templates guide](../guides/templates.mdx).

### module

The `wails generate module` command allows you to manually generate the `wailsjs` directory for your application.

## update

`wails update` will update the version of the Wails CLI.

| Option             | Description                           |
|:------------------ |:------------------------------------- |
| -pre               | Update to latest pre-release version  |
| -version "version" | Install a specific version of the CLI |

## version

`wails version` will simply output the current CLI version.
