---
sidebar_position: 2
---

# Linha de comandos

A CLI do Wails tem vários comandos que são usados para gerenciar seus projetos. Todos os comandos são executados da seguinte maneira:

`wails <command> <flags>`

## init

`wails init` é usado para gerar projetos.

| Flag                      | Descrição                                                                                                                          |     Padrão      |
|:------------------------- |:---------------------------------------------------------------------------------------------------------------------------------- |:---------------:|
| -n "nome do projeto"      | Nome do projeto. **Obrigatório**.                                                                                                  |                 |
| -d "diretório do projeto" | Diretório de projeto a criar                                                                                                       | Nome do projeto |
| -g                        | Inicializar o repositório git                                                                                                      |                 |
| -l                        | Listar modelos de projetos disponíveis                                                                                             |                 |
| -q                        | Suprimir saída no console                                                                                                          |                 |
| -t "nome do template"     | O modelo do projeto a ser usado. Este pode ser o nome de um template padrão ou um URL para um template remoto hospedado no github. |     vanilla     |
| -ide                      | Gerar arquivos de projeto IDE                                                                                                      |                 |
| -f                        | Forçar compilação de aplicação                                                                                                     |      false      |

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

Isso irá gerar um projeto chamado "test" no diretório "mytestproject", inicializar o git, gerar arquivos de projeto vscode e fazê-lo silenciosamente.

Mais informações sobre isso podem ser encontradas [aqui](../guides/ides.mdx).

### Modelos Remotos

Modelos remotos (hospedados no GitHub) são suportados e podem ser instalados usando a URL do projeto do template.

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

Uma lista de modelos mantidos pela comunidade pode ser encontrada [aqui](../community/templates.mdx)

:::warning Attention

**The Wails project does not maintain, is not responsible nor liable for 3rd party templates!**

If you are unsure about a template, inspect `package.json` and `wails.json` for what scripts are run and what packages are installed.

:::

## build

`wails build` é usado para compilar seu projeto para um binário pronto para produção.

| Flag                 | Descrição                                                                                                                                                                          | Padrão                                                                                                                                                |
|:-------------------- |:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |:----------------------------------------------------------------------------------------------------------------------------------------------------- |
| -platform            | Compila para as plataformas [(delimitadas por vírgula)](../reference/cli.mdx#platforms) por exemplo. `windows/arm64`. Note, se você não der arquitetura, `runtime.GOARCH` é usado. | platform = `variável de ambiente GOOS` se determinado `runtime.GOOS`.<br/>arch = `GOARCH` variável de envrionment se for dado `runtime.GOARCH`. |
| -clean               | Limpa o diretório `compilação/bin`                                                                                                                                                 |                                                                                                                                                       |
| -compiler "compiler" | Use um compilador de ida diferente para realizar build, por exemplo, go1.15beta1                                                                                                   | go                                                                                                                                                    |
| -ldflags "flags"     | Ldflags adicionais para passar para o compilador                                                                                                                                   |                                                                                                                                                       |
| -nopackage           | Não empacotar aplicação                                                                                                                                                            |                                                                                                                                                       |
| -o nome de arquivo   | Nome do Arquivo de Saída                                                                                                                                                           |                                                                                                                                                       |
| -s                   | Pular build do frontend                                                                                                                                                            | false                                                                                                                                                 |
| -f                   | Forçar compilação de aplicação                                                                                                                                                     | false                                                                                                                                                 |
| -tags "extra tags"   | Compilar tags para passar para o compilador Go. Deve ser citado. Separados por espaço ou vírgula (mas não ambos)                                                                   |                                                                                                                                                       |
| -upx                 | Comprimir binário final usando "upx"                                                                                                                                               |                                                                                                                                                       |
| -upxflags            | Flags para passar para o upx                                                                                                                                                       |                                                                                                                                                       |
| -v int               | Nível de verbosidade(0 - silencioso, 1 - padrão, 2 - verbose)                                                                                                                      | 1                                                                                                                                                     |
| -webview2            | Estratégia de instalação WebView2: download,embed,browser,error                                                                                                                    | baixar                                                                                                                                                |
| -u                   | Atualiza o `go.mod` do seu projeto para usar a mesma versão de Wails que o CLI                                                                                                     |                                                                                                                                                       |
| -debug               | Mantém as informações de depuração no aplicativo. Permite o uso das ferramentas devtools na janela do aplicativo                                                                   | false                                                                                                                                                 |
| -trimpath            | Remove todos os caminhos do sistema de arquivo do executável resultante.                                                                                                           | false                                                                                                                                                 |
| -race                | Realiza build com o Go race detector                                                                                                                                               | false                                                                                                                                                 |
| -windowsconsole      | Manter a janela de console para builds do Windows                                                                                                                                  |                                                                                                                                                       |
| -obfuscate           | Ofuscar a aplicação usando [garble](https://github.com/burrowers/garble)                                                                                                           | false                                                                                                                                                 |
| -garbleargs          | Argumentos para passar para o garble                                                                                                                                               | `-literals -tiny -seed=random`                                                                                                                        |
| -nosyncgomod         | Do not sync go.mod with the Wails version                                                                                                                                          | false                                                                                                                                                 |

Para uma descrição detalhada do sinalizador `webview2`, consulte o guia [Windows](../guides/windows.mdx).

Se você preferir construir usando a ferramenta Go padrão, consulte o guia de [Builds Manuais](../guides/manual-builds.mdx).

Exemplo:

`wails build -clean -o myproject.exe`

:::info

On Mac, the application will be bundled with `Info.plist`, not `Info.dev.plist`.

:::

:::info UPX no Apple Silicon

Há alguns [problemas](https://github.com/upx/upx/issues/446) com o uso de UPX com o Apple Silicon.

:::

:::info UPX no Windows

Alguns fornecedores de antivírus marcam como falsos positivos os binários `upx` comprimidos como vírus, veja [problema](https://github.com/upx/upx/issues/437).

:::

### Plataformas

Plataformas Suportadas:

| Plataforma       | Descrição                                     |
|:---------------- |:--------------------------------------------- |
| darwin           | MacOS + architecture of build machine         |
| darwin/amd64     | MacOS 10.13+ AMD64                            |
| darwin/arm64     | MacOS 11.0+ ARM64                             |
| darwin/universal | MacOS AMD64+ARM64 universal application       |
| windows          | Windows 10/11 + architecture of build machine |
| windows/amd64    | Windows 10/11 AMD64                           |
| windows/arm64    | Windows 10/11 ARM64                           |
| linux            | Linux + architecture of build machine         |
| linux/amd64      | Linux AMD64                                   |
| linux/arm64      | Linux ARM64                                   |

## doctor

`wails doctor` executará o diagnóstico para garantir que seu sistema esteja pronto para desenvolvimento.

Exemplo:

```
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` é usado para executar sua aplicação em um modo de "desenvolvimento ao vivo". Isso significa que:

- O aplicativo `go.mod` será atualizado para usar a mesma versão do Wails como a CLI
- A aplicação é compilada e executada automaticamente
- Um observador é iniciado e acionará uma reconstrução do seu aplicativo de desenvolvimento se ele detectar alterações em seus arquivos go
- Um servidor web foi iniciado em `http://localhost:34115` que serve sua aplicação (não apenas frontend) sobre http. Isso permite que você use suas extensões de desenvolvimento de navegador favoritas
- Todos os conteúdos do aplicativo são carregados do disco. Se forem alterados, o aplicativo irá recarregar automaticamente (não reconstruir). Todos os navegadores conectados também recarregarão
- Um módulo JS é gerado que fornece o seguinte:
  - JavaScript wrappers of your Go methods with autogenerated JSDoc, providing code hinting
  - Versões do TypeScript de suas structs Go, que podem ser construídas e passadas para os métodos da sua ida
- Um segundo módulo JS é gerado que fornece uma declaração wrapper + TS para o tempo de execução
- No macOS, ele irá empacotar a aplicação em um arquivo `.app` e executá-lo. Será usado um `build/darwin/Info.dev.plist` para desenvolvimento.

| Flag                              | Descrição                                                                                                                                                        | Padrão                |
|:--------------------------------- |:---------------------------------------------------------------------------------------------------------------------------------------------------------------- |:--------------------- |
| -assetdir "./caminho/para/midias" | Serve os arquivos a partir do diretório fornecido em vez de usar os arquivos FS fornecidos                                                                       | Valor em `wails.json` |
| -browser                          | Abre um navegador para `http://localhost:34115` na inicialização                                                                                                 |                       |
| -compiler "compiler"              | Use um compilador de ida diferente para realizar build, por exemplo, go1.15beta1                                                                                 | go                    |
| -e                                | Extensões para acionar reconstruções (separadas por vírgula)                                                                                                     | go                    |
| -reloaddirs                       | Diretórios adicionais para acionar recarregamentos (separados por vírgula)                                                                                       | Valor em `wails.json` |
| -ldflags "flags"                  | Ldflags adicionais para passar para o compilador                                                                                                                 |                       |
| -tags "extra tags"                | Compilar tags para passar para o compilador (citado e espaço separado)                                                                                           |                       |
| -loglevel "loglevel"              | Nível de log a ser usado - Trace, Debug, Info, Warning, Error                                                                                                    | Debug                 |
| -noreload                         | Desativar a recarga automática quando os arquivos forem alterados                                                                                                |                       |
| -nocolour                         | Desativar saída da colorida da cli                                                                                                                               | false                 |
| -nogen                            | Desativar módulo de geração                                                                                                                                      |                       |
| -v                                | Nível de verbosidade(0 - silencioso, 1 - padrão, 2 - verbose)                                                                                                    | 1                     |
| -wailsjsdir                       | O diretório para gerar os módulos gerados do Wails JS                                                                                                            | Valor em `wails.json` |
| -debounce                         | O tempo de esperar por recarregar depois que uma alteração de ativo for detectada                                                                                | 100 (milliseconds)    |
| -devserver "host:port"            | O endereço para vincular o servidor de desenvolvimento de wails a                                                                                                | "localhost:34115"     |
| -frontenddevserverurl "url"       | Usar URL do servidor de desenvolvimento de terceiros para servir midias, Vite EG                                                                                 | ""                    |
| -appargs "args"                   | Argumentos passados para o aplicativo no estilo shell                                                                                                            |                       |
| -save                             | Salva o `assetdir`, `reloaddirs`,`wailsjsdir`,`debounce`,`devserver` e `frontenddevserverurl` passado, flag em `wails.json` para realizar chamadas subsequentes. |                       |
| -race                             | Realiza build com o Go race detector                                                                                                                             | false                 |
| -s                                | Pular build do frontend                                                                                                                                          | false                 |
| -nosyncgomod                      | Do not sync go.mod with the Wails version                                                                                                                        | false                 |



Exemplo:

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

Este comando fará o seguinte:

- Compilação do aplicativo e execução (mais detalhes [aqui](../guides/manual-builds.mdx)
- Gerar os módulos JS de Wails em `./frontend/src`
- Assistir por atualizações em arquivos em `./frontend/dist` e recarregar em qualquer alteração
- Abrir um navegador e conectar-se ao aplicativo

Há mais informações sobre como usar este recurso com scripts de framework existentes [aqui](../guides/application-development.mdx#live-reloading).

## generate

### template

A Wails usa modelos para a geração de projeto. O comando `wails generate template` ajuda a fazer um template para que ele possa ser usado para gerar projetos.

| Flag             | Descrição                                             |
|:---------------- |:----------------------------------------------------- |
| -name            | O nome do template (Obrigatório)                      |
| -frontend "path" | Caminho para o projeto frontend para usar no template |

Para mais detalhes sobre a criação de modelos, consulte o [guia de Modelos](../guides/templates.mdx).

### module

O comando `wails generate template` permite que você gere manualmente o diretório `wailsjs` para o seu aplicativo.

## update

`wails update` irá atualizar a versão da CLI do Wails.

| Flag               | Descrição                             |
|:------------------ |:------------------------------------- |
| -pre               | Atualizar para a versão mais recente  |
| -version "version" | Instalar uma versão específica do CLI |

## version

`wails version` simplesmente irá retornar a versão CLI atual.
