Attention: Here be dragons

This is the latest (unstable) version of this documentation, which may document features not available in or compatible with released stable versions of Godot.

Checking the stable version of the documentation...

Criando aplicações

O Godot apresenta um sistema de UI integrado abrangente, e seu pequeno tamanho de distribuição pode torná-lo uma alternativa adequada a frameworks como Electron ou Qt.

Esta página fornece diretrizes para a criação de aplicativos não relacionados a jogos com o Godot, bem como instruções sobre como executar tarefas comuns para melhorar a integração com o desktop.

Nota

O Godot é, antes de tudo, um motor de jogos. Isso significa que a criação de aplicativos com o Godot é um subproduto do seu conjunto de recursos, e não o foco principal do seu desenvolvimento.

Ver também

Confira Material Maker e Pixelorama para exemplos de aplicativos de código aberto desenvolvidos com o Godot.

Executando tarefas comuns

Gerando múltiplas janelas

Isso é suportado apenas no Windows, macOS e Linux (apenas X11/XWayland, não no modo Wayland nativo).

Janelas adicionais podem ser criadas usando o nó Window. As janelas podem ser movidas, redimensionadas, minimizadas e fechadas independentemente da janela principal do aplicativo.

No entanto, se você fechar a janela principal, todas as outras janelas também serão fechadas, já que fechar a janela principal encerra o processo. Você pode evitar isso minimizando a janela principal, definindo sua propriedade unfocusable como true (para ocultá-la da barra de tarefas e do alternador de tarefas) e, em seguida, criando nós Window adicionais imediatamente na inicialização. Lembre-se de fornecer um meio alternativo de sair do aplicativo nesse caso, como um ícone de bandeja.

Restringindo o tamanho da janela

A maioria dos aplicativos só consegue renderizar corretamente a partir de um determinado tamanho mínimo de janela. Para casos de uso mais específicos, também pode ser desejável forçar um tamanho máximo de janela.

Os limites de tamanho podem ser aplicados usando as propriedades min_size e max_size em um nó Window. Lembre-se de multiplicar esses limites de tamanho de acordo com o fator de escala do aplicativo (consulte Dimensionamento para telas hiDPI para obter detalhes).

Dica

Como lembrete, você pode recuperar o nó Window raiz para definir propriedades nele usando get_window() em qualquer nó.

Usando caixas de diálogo nativas de arquivo

Isso é suportado apenas no Windows, macOS, Linux e Android.

Por padrão, o Godot usa sua própria implementação FileDialog para caixas de diálogo de arquivos. No entanto, você pode usar as caixas de diálogo de arquivos nativas do sistema operacional. Isso geralmente é preferido pelos usuários, pois as caixas de diálogo nativas se integram melhor ao ambiente de desktop e oferecem uma experiência mais familiar.

Você pode optar pelas caixas de diálogo de arquivos nativas ativando a propriedade use_native_dialog no nó FileDialog. Isso deve ser feito em cada nó FileDialog usado no projeto, pois não há uma configuração de projeto para controlar esse comportamento globalmente.

Comparação entre o FileDialog padrão (à esquerda) e a caixa de diálogo de arquivos nativa (à direita) no macOS

Comparação entre o FileDialog padrão (à esquerda) e a caixa de diálogo de arquivos nativa (à direita) no macOS

Nota

Consulte a descrição da propriedade para obter detalhes sobre o suporte à plataforma.

Além disso, no macOS, as caixas de diálogo de arquivos nativas não são suportadas quando a incorporação de jogos está ativada no editor. Para testar essa funcionalidade ao executar o projeto, certifique-se de desativar a incorporação de jogos alternando para a tela Game, clicando no ícone mais à direita na barra na parte superior e desmarcando Embed Game on Next Play.

Criando um ícone na bandeja do sistema

Isso é suportado apenas no Windows e macOS.

Você pode criar um ou mais ícones na bandeja do sistema (também conhecida como área de notificação) usando um nó StatusIndicator. Além de uma dica de ferramenta, esse nó pode ter um nó PopupMenu atribuído, de modo que um menu suspenso possa ser exibido ao clicar no ícone.

O StatusIndicator também tem um sinal pressed que é emitido quando o ícone é clicado. Use isso para realizar uma ação sem fazer com que um menu suspenso apareça, ou realize ações diferentes dependendo de qual botão do mouse foi pressionado.

Depois de criar um ícone de bandeja, você também pode querer implementar o comportamento de "minimizar ao fechar". Isso significa que quando o usuário tentar fechar o aplicativo usando o botão X do gerenciador de janelas, ele será minimizado na bandeja. Para fazer isso, anexe este script a uma cena de Autoload com um StatusIndicator como o nó raiz:

extends StatusIndicator

# Disable this behavior when running from the editor with game embedding,
# as it doesn't cooperate well.
var tray_icon_supported = (
        DisplayServer.has_feature(DisplayServer.FEATURE_STATUS_INDICATOR)
        and not Engine.is_embedded_in_editor()
    )


func _ready():
    visible = false

    if tray_icon_supported:
        get_tree().auto_accept_quit = false
        get_window().focus_entered.connect(
                func():
                    # Hide the tray icon when the window gains focus,
                    # which means it was restored from its minimized state.
                    visible = false
            )
        pressed.connect(
                func(_mouse_button, _position):
                    # Restore the application when the tray icon is clicked.
                    get_window().mode = Window.MODE_WINDOWED
            )


func _notification(what):
    if not tray_icon_supported:
        return

    match what:
        NOTIFICATION_WM_CLOSE_REQUEST:
            get_window().mode = Window.MODE_MINIMIZED
            # Show the tray icon.
            visible = true

Consulte Tratamento de solicitações de saída para obter detalhes sobre como substituir o comportamento quando o usuário tenta fechar o aplicativo. É importante lidar com isso quando o usuário tiver alterações não salvas para evitar a perda de dados.

Nota

Quando vários nós StatusIndicator estão presentes, sua ordem na bandeja do sistema é determinada pela ordem em que são adicionados à árvore da cena.

Usando o menu global

Isso é suportado apenas no macOS.

No macOS, os aplicativos podem usar la barra de menus global do sistema em vez de exibir uma barra de menus dentro da janela do aplicativo. Isso também é conhecido como um menu nativo no Godot.

Comparação entre o MenuBar padrão (esquerda), MenuBar com popups nativos (meio) e menu nativo (direita) no macOS

Comparação entre o MenuBar padrão (esquerda), MenuBar com popups nativos (meio) e menu nativo (direita) no macOS

O Godot suporta a criação de menus por meio do nó MenuBar, que exibe seus filhos PopupMenu como menus. Você pode ativar o suporte ao menu global em um determinado nó MenuBar ativando sua propriedade prefer_global_menu no inspetor. No macOS, isso fará com que o nó MenuBar desapareça e não ocupe espaço, com seus menus sendo exibidos na barra de menus global do sistema. Se essa propriedade estiver desativada, o nó MenuBar exibirá seus menus dentro da janela do aplicativo como de costume, mas os popups nativos ainda serão usados quando suportados pelo sistema operacional.

Nota

O menu do aplicativo (com o nome do projeto em negrito), bem como os menus Window e Help, estão sempre presentes no macOS. Você não deve adicioná-los manualmente ao menu global.

No Godot 4.6 e posterior, você pode adicionar novos itens dentro desses menus alterando a propriedade system_menu_id no nó PopupMenu. Você pode escolher entre Application Menu (o primeiro menu com o nome do aplicativo em negrito), Window Menu, Help Menu e Dock (mostrado ao clicar com o botão direito no ícone no Dock). Os itens de menu padrão que já estão presentes nesses menus serão preservados:

Opções personalizadas adicionadas ao menu de sistema Window no macOS

Opções personalizadas adicionadas ao menu de sistema Window no macOS

Um projeto pode ter vários nós MenuBar. Se vários nós MenuBar tiverem a propriedade Prefer Global Menu ativada, as opções de menu serão adicionadas no índice definido pela propriedade Start Index quando o nó MenuBar for adicionado à árvore da cena. Isso permite colocar menus específicos de contexto no final da barra de menus, para que as primeiras opções de menu permaneçam no lugar quando a barra de menus adicional for adicionada ou removida.

Para casos de uso mais avançados, você também pode usar o singleton NativeMenu diretamente, sem usar o nó MenuBar.

Nota

A integração do menu global não é suportada quando a incorporação de jogos está ativada no editor. Para testar essa funcionalidade ao executar o projeto, certifique-se de desativar a incorporação de jogos alternando para a tela Game, clicando no ícone mais à direita na barra na parte superior e desmarcando Embed Game on Next Play.

Usando decorações do lado do cliente

Isso é suportado apenas no macOS.

Muitos aplicativos modernos usam decorações do lado do cliente (CSD) em vez de depender do gerenciador de janelas do sistema operacional para desenhar a barra de título e as bordas da janela (decorações do lado do servidor). Isso permite uma aparência mais personalizável e uma melhor integração com a interface do usuário do aplicativo.

Atualmente, o Godot suporta decorações do lado do cliente apenas no macOS. Isso pode ser usado ativando a configuração de projeto display/window/size/extend_to_title.

Comparação entre decorações de janela padrão (superior) e decorações do lado do cliente (inferior) no macOS

Comparação entre decorações de janela padrão (superior) e decorações do lado do cliente (inferior) no macOS

Depois de ativar as decorações do lado do cliente, a borda da janela não será mais exibida e os botões de minimizar/maximizar/fechar serão mostrados como uma sobreposição ao aplicativo. Você precisa garantir que o aplicativo forneça uma margem suficiente na parte superior para que os botões sejam exibidos confortavelmente, ao mesmo tempo em que exibe o título da janela usando um nó Label ou similar.

Para adaptar condicionalmente sua interface de usuário dependendo se as decorações do lado do cliente estão ativadas, use DisplayServer.has_feature e verifique também o valor atual de Window.extend_to_title (que é o que a configuração do projeto altera):

func _ready():
    if DisplayServer.has_feature(FEATURE_EXTEND_TO_TITLE) and get_window().extend_to_title:
        # Adjust UI for client-side decorations (a MarginContainer node
        # can be useful here). Also set the window title to be displayed
        # according to the native window title.
        $WindowTitle.visible = true
        $WindowTitle.text = get_window().title
        if OS.is_debug_build():
            $WindowTitle.text += " (DEBUG)"

Para posicionar corretamente o título da janela, considere o uso de DisplayServer.window_get_safe_title_margins(), que retorna um Vector3 onde x é a margem esquerda, y é a margem direita (aumentará quando o sistema usar composição de texto da direita para a esquerda) e z é a altura. Além disso, você pode chamar DisplayServer.window_set_window_buttons_offset() para ajustar a posição dos botões fechar/minimizar/maximizar (geralmente para centralizá-los verticalmente).

Margens de título seguras ao usar decorações do lado do cliente no macOS

Margens de título seguras ao usar decorações do lado do cliente no macOS

Nota

No macOS, as decorações do lado do cliente não são suportadas quando a incorporação de jogos está ativada no editor. Para testar essa funcionalidade ao executar o projeto, certifique-se de desativar a incorporação de jogos alternando para a tela Game, clicando no ícone mais à direita na barra na parte superior e desmarcando Embed Game on Next Play.

Exibindo o status de progresso na barra de tarefas/Dock

Isso é suportado apenas no Windows e macOS.

É possível que os aplicativos relatem um status de progresso ao sistema operacional, que pode ser exibido na barra de tarefas ou no ícone do Dock. Esse status é composto por um estado (ativo, pausado, erro) e uma porcentagem de conclusão. Isso pode ser usado para mostrar o progresso enquanto o usuário não está focado no aplicativo.

Relatório de progresso no Dock no macOS

Relatório de progresso no Dock no macOS

Isso geralmente é feito sincronizando o progresso de um nó ProgressBar com o progresso relatado ao sistema operacional:

func set_progress(value, indeterminate = false):
    $ProgressBar.value = value
    $ProgressBar.indeterminate = indeterminate

    if $ProgressBar.indeterminate:
        get_window().set_taskbar_progress_state(DisplayServer.PROGRESS_STATE_INDETERMINATE)
    else:
        get_window().set_taskbar_progress_state(DisplayServer.PROGRESS_STATE_NORMAL)

    # The taskbar progress value must be between `0.0` and `1.0`
    # (values outside this range are clamped).
    # ProgressBar provides a `ratio` property that represents its current progress
    # as a value between `0.0` and `1.0`.
    get_window().set_taskbar_progress_value($ProgressBar.ratio)

Vários estados de progresso estão disponíveis: sem progresso (oculta a barra de progresso), indeterminado, normal, pausado, erro. Verifique a referência da classe para obter detalhes.

Você também pode usar Window.request_attention() para fazer a janela piscar na barra de tarefas (ou pular no Dock no macOS). Por exemplo, isso pode ser usado para atrair a atenção do usuário após a conclusão de uma operação longa.

Nota

O relatório de progresso não é suportado quando a incorporação de jogos está ativada no editor. Para testar essa funcionalidade ao executar o projeto, certifique-se de desativar a incorporação de jogos alternando para a tela Game, clicando no ícone mais à direita na barra na parte superior e desmarcando Embed Game on Next Play.

Enviando notificações de área de trabalho

Atualmente, o Godot não possui suporte nativo para o envio de notificações de desktop.

No entanto, no macOS e no Linux, você pode usar os utilitários de linha de comando osascript e notify-send, respectivamente, para enviar notificações de desktop:

func send_notification(title, message):
    var app_name = ProjectSettings.get_setting("application/config/name")
    if app_name.is_empty():
        app_name = "Unnamed Project"

    if OS.has_feature("macos") and not OS.is_sandboxed():
        # Note that this will not work if the project is exported in sandbox mode
        # (e.g. for the Mac App Store).
        OS.execute("osascript", [
                "-e",
                'display notification \\"%s\\" with title \\"%s\\" subtitle \\"%s\\"' % [
                    message,
                    app_name,
                    title,
                ]
            ])
    elif OS.has_feature("linuxbsd"):
        OS.execute("notify-send", ["--app-name", app_name, title, message])

func _ready():
    send_notification("Success", "Operation completed successfully.")

Infelizmente, não há equivalente que esteja disponível nativamente no Windows.

Lembrando a posição e o tamanho da janela entre as sessões

O Godot não tem suporte integrado para lembrar a posição e o tamanho da janela entre as sessões, mas isso pode ser implementado manualmente usando um script. Um exemplo básico que suporta configurações de vários monitores seria um Autoload com este script:

extends Node

# Use a dedicated configuration file for the window state.
# This way, the application's other configuration files are left
# untouched and can be put in version control without unnecessary diffs
# being produced.
const CONFIG_WINDOW_PATH = "user://window.ini"

var config_file = ConfigFile.new()


func _enter_tree():
    config_file.load(CONFIG_WINDOW_PATH)

    # Do not restore previous window state if running from the editor
    # with game embedding enabled.
    if not Engine.is_embedded_in_editor():
        var window_screen = config_file.get_value("main", "screen", -1)
        if window_screen is int:
            get_window().current_screen = window_screen

        var window_mode = config_file.get_value("main", "mode", -1)
        if window_mode is Window.Mode:
            get_window().mode = window_mode

        var window_position = config_file.get_value("main", "position", -1)
        if window_position is Vector2i:
            get_window().position = window_position

        var window_size = config_file.get_value("main", "size", -1)
        if window_size is Vector2i:
            get_window().size = window_size


func _exit_tree():
    # Save the current window state when the application is quit normally.
    # In a real world scenario, it's recommended to also save this information
    # regularly (e.g. with a Timer node), so that the window state can be
    # restored after a crash or when terminated externally.
    config_file.set_value("main", "screen", get_window().current_screen)
    config_file.set_value("main", "mode", get_window().mode)
    config_file.set_value("main", "position", get_window().position)
    config_file.set_value("main", "size", get_window().size)
    config_file.save(CONFIG_WINDOW_PATH)

Nota

O exemplo acima rastreia apenas a posição da janela principal. Em aplicativos que geram várias janelas, você precisará salvar e carregar a posição e o tamanho de cada janela separadamente.

Ocultando a janela durante a tela de abertura (splash screen)

Para alguns aplicativos, pode ser preferível ocultar a tela de abertura para desenhar uma tela de abertura personalizada com uma barra de progresso (ou até mesmo nenhuma tela de abertura, se o aplicativo inicializar rapidamente).

O Godot carece de suporte nativo para ocultar a janela durante a tela de abertura, mas você pode conseguir isso usando uma janela transparente muito pequena nas configurações do projeto, redimensionando a janela e desativando a transparência assim que a cena principal for carregada.

Para fazer isso, as configurações do projeto devem ser configuradas da seguinte forma:

Este script pode ser usado como um Autoload para restaurar as configurações originais assim que a tela de abertura terminar de ser exibida:

extends Node


func _enter_tree():
    # Wait a frame to be rendered before restoring the window properties.
    # Otherwise, properties will be restored too early and the window border
    # will show up around a transparent window.
    await get_tree().process_frame

    get_viewport().transparent_bg = false
    get_window().transparent = false
    get_window().borderless = false
    get_window().size = Vector2i(1152, 648)

Exibindo a aplicação como uma sobreposição (overlay)

É possível exibir a janela do aplicativo como uma sobreposição que fica em cima de outras janelas. Isso pode ser útil para aplicativos como widgets ou monitores de sistema.

Para fazer isso, habilite todas as seguintes configurações de projeto:

Lembre-se de posicionar e redimensionar a janela usando scripts, pois uma janela sem bordas geralmente não pode ser movida pelo usuário.

Para permitir que a entrada do mouse passe para o aplicativo em segundo plano, defina a propriedade mouse_passthrough como true na Window que está sendo desenhada como uma sobreposição. Você também pode definir um polígono em mouse_passthrough_polygon, para que certas áreas ainda possam interceptar a entrada do mouse na sobreposição.

Adicionalmente, você pode querer definir a propriedade exclude_from_capture como true para evitar que a sobreposição apareça em capturas de tela ou gravações. Essa dica é implementada apenas no Windows e no macOS e funciona na base do melhor esforço, portanto, não deve ser usada como uma medida de segurança absoluta ou DRM.

Nota

A exibição como sobreposição não é suportada quando a incorporação de jogos está ativada no editor. Para testar essa funcionalidade ao executar o projeto, certifique-se de desativar a incorporação de jogos alternando para a tela Game, clicando no ícone mais à direita na barra na parte superior e desmarcando Embed Game on Next Play.

Além disso, lembre-se de que as sobreposições não podem ser mostradas em cima de outro aplicativo se o aplicativo em questão usar tela cheia exclusiva. Em vez disso, a tela cheia sem bordas deve ser usada para que as sobreposições fiquem visíveis.

Também existem problemas conhecidos com a exibição de janelas transparentes no Windows com configurações de GPU híbrida (como NVIDIA Optimus). A alternância de renderizadores pode ajudar a resolver o problema.

No Linux com X11, a transparência não funcionará se o usuário tiver desativado a composição nas configurações do gerenciador de janelas.

Dimensionamento para telas hiDPI

As telas modernas variam muito em termos de densidade de pixels, o que significa que um fator de escala diferente é frequentemente necessário para garantir que os elementos da interface do usuário sejam legíveis. O fator de escala também pode ser fornecido como um ajuste manual para o usuário, de modo que o aplicativo continue confortável de usar.

O suporte a múltiplas resoluções do Godot é bem adequado para dimensionar aplicativos quando configurado corretamente. Siga as instruções na seção de aplicativos que não são jogos da documentação de Múltiplas resoluções.

Nota

Atualmente, o Godot suporta apenas a leitura do fator de escala da tela a partir das configurações do sistema operacional no macOS, Android e Linux (somente Wayland). No Linux (X11) e no Windows, você precisará fornecer uma opção de dimensionamento manual para o usuário ajustar a escala da interface do usuário conforme necessário.

Integração com leitor de tela

Os leitores de tela permitem que pessoas com deficiência visual usem um aplicativo lendo os elementos da interface do usuário e fornecendo controles de navegação. As telas Braille são outra abordagem que também depende de informações de acessibilidade para funcionar corretamente.

O Godot ativa automaticamente o suporte ao leitor de tela se for detectado que um leitor de tela está em execução. Isso pode ser configurado nas Configurações do Projeto usando accessibility/general/accessibility_support para desativá-lo em situações em que não seja desejado. Ele também pode ser ativado obrigatoriamente, o que é útil ao usar ferramentas de depuração de acessibilidade que não são reconhecidas como leitores de tela pelo Godot.

O Godot usa a biblioteca AccessKit para integração com leitores de tela.

Dica

Como o suporte ao leitor de tela usa o próprio aplicativo de leitor de tela para reproduzir áudio (em vez do projeto Godot), ele funcionará mesmo se o driver de áudio estiver definido como Dummy nas configurações do projeto, conforme descrito abaixo.

É fortemente recomendável testar seu aplicativo com leitores de tela populares em suas plataformas de destino para garantir uma boa experiência de usuário para usuários com deficiência visual. Os exemplos incluem NVDA no Windows, VoiceOver no macOS e Orca no Linux.

Para levar o suporte ao leitor de tela a um bom nível de usabilidade, são necessários volumes significativos de trabalho. Você precisa definir rótulos de acessibilidade usando as propriedades Control.accessibility_name e Control.accessibility_description e garantir que a interface do usuário flua em uma ordem lógica quando lida por um leitor de tela.

Ver também

Consulte também Texto para voz para funcionalidade de conversão de texto em fala que é separada dos leitores de tela.

Adicionando testes unitários

Em um aplicativo, geralmente há mais valor em ter uma configuração de testes unitários em comparação com um jogo. Isso pode ser usado para detectar regressões de maneira automatizada, o que tende a ser mais fácil de fazer em um cenário de aplicativo onde a lógica pode ser separada de forma limpa.

O GDScript não possui um framework de testes unitários integrado, mas existem vários plugins para testes unitários mantidos pela comunidade:

Com C# e GDExtension (C++, Rust, etc.), você pode usar frameworks de teste padrão como NUnit ou doctest.

Otimizando o tamanho da distribuição

Como os aplicativos que não são jogos geralmente evitam o uso de grandes partes do motor, como funcionalidades de áudio ou 3D, você pode compilar um modelo de exportação otimizado para reduzir o tamanho do arquivo. Isso também melhorará os tempos de inicialização, especialmente na plataforma web, onde o tamanho do binário está diretamente ligado à velocidade de inicialização.

A redução de tamanho geralmente é significativa (em relação ao tamanho do projeto), já que os aplicativos contêm menos recursos grandes em comparação com os jogos. Veja Otimizando uma compilação para o tamanho para mais informações sobre como fazer isso.

Criando uma distribuição de executável único

Por padrão, o Godot cria um arquivo PCK contendo os dados do projeto ao lado do executável. Isso significa que se o executável for movido sem mover o arquivo PCK ao mesmo tempo, o aplicativo não será executado. Isso não é o ideal para aplicativos, que estão sendo cada vez mais distribuídos como um único arquivo executável.

Para tornar o aplicativo totalmente autônomo em um único executável, você pode ativar Embed PCK nas opções de predefinição de exportação. Isso incorporará os dados do PCK dentro do executável, de modo que o aplicativo possa ser movido sem quebrar. Isso também torna possível executar o aplicativo diretamente de um arquivo ZIP sem ter que extraí-lo primeiro.

Nota

A incorporação do PCK possui uma limitação de tamanho dependendo da plataforma. Aplicativos muito grandes (vários GBs) podem não conseguir usar esse recurso em todas as plataformas. Verifique a documentação de exportação da plataforma de destino para mais detalhes.

Criando aplicações portáteis

Um aplicativo é chamado de portátil quando pode ser executado sem instalação e quando sua configuração é inteiramente contida na pasta para a qual foi extraído. Isso permite colocar os arquivos do aplicativo em um pen drive USB ou similar e executá-lo em diferentes máquinas sem ter que passar por um processo de instalação.

O próprio modo autônomo do editor do Godot atualmente não pode ser usado dentro de projetos. No entanto, você ainda pode optar por salvar seus próprios arquivos de configuração na pasta que contém o executável da seguinte forma:

var config_path = OS.get_executable_path().get_base_dir().path_join("config.ini")
# Then use `config_path` to save/load configuration files using ConfigFile or similar.

Você pode querer tornar o modo portátil opcional, pois ele nem sempre é desejado. Normalmente, isso é feito detectando a presença de um arquivo específico na pasta do executável (por exemplo, um arquivo chamado portable.txt) e apenas usando a pasta do executável para configuração se esse arquivo estiver presente.

Aviso

Lembre-se de que isso só funcionará se o aplicativo for extraído para um local com permissão de escrita. Isso resultará em erros de permissão se o executável for executado a partir de um local de apenas leitura, como C:\Program Files no Windows.

Criando instaladores

Embora os jogos sejam normalmente instalados por meio de inicializadores como o Steam ou baixados como um ZIP, os aplicativos costumam ser distribuídos como instaladores para uma melhor integração com o desktop. O instalador pode realizar ações como adicionar atalhos ao Menu Iniciar ou à área de trabalho, configurar associações de arquivos e muito mais. Os instaladores também podem ser executados automaticamente por meio da linha de comando, o que os torna mais desejáveis para ambientes corporativos.

O Godot não possui suporte integrado para a criação de instaladores para projetos exportados. No entanto, ainda é possível criar seus próprios instaladores usando ferramentas de terceiros.

Aqui está uma lista não exaustiva de ferramentas que podem ser usadas para criar instaladores:

  • Windows: Inno Setup, NSIS

    • Se você tiver um certificado de assinatura de código, lembre-se de assinar tanto o instalador quanto o executável do projeto. Para fazer isso, assine o executável do projeto exportado, crie o instalador contendo o projeto exportado e, em seguida, assine manualmente o instalador que você acabou de criar.

  • macOS: create-dmg

  • Linux: Flatpak

    • Existe um Godot BaseApp que pode ser usado como base para a criação de pacotes Flatpak para projetos Godot. Veja o Flatpak do Pixelorama para um exemplo de Flatpak que faz uso deste BaseApp.

Recursos

Estas páginas cobrem tarefas comumente realizadas em aplicativos que não são jogos: