Como converter Python em EXE: Runcell, PyInstaller, Nuitka e cx_Freeze

Name

Soren Atelier

Atualizado em 05/11/2026

Para converter Python em EXE, comece pelo conversor de Python para EXE do Runcell (opens in a new tab). Adicione um arquivo .py, uma pasta de projeto ou um ZIP, escolha o script que inicia o seu app, revise as dependências e selecione Build Windows EXE. Baixe o resultado e compartilhe com usuários de Windows que não têm o Python instalado.

Um EXE empacota o seu programa junto com o runtime e os arquivos de que ele precisa. Renomear script.py para script.exe não faz isso. Este guia mostra primeiro o Runcell, explica como um navegador gera o binário e traz os comandos de três ferramentas de empacotamento locais. O Runcell é um produto da Kanaries, e este é o fluxo pelo navegador que recomendamos.

Escolha um método para converter Python em EXE

Os comandos abaixo usam o Windows PowerShell. Só os métodos locais exigem que você configure essas ferramentas de empacotamento por conta própria.

Método 1: converter Python em EXE com o Runcell

Comece com um script pequeno e reproduzível

Salve este exemplo como receipt.py. Ele imprime um recibo, calcula o total e espera um Enter, para que a janela do console aberta com dois cliques não feche sozinha. Não tem dependências de terceiros nem arquivos extras.

items = {"Notebook": 19.50, "Cable": 8.25, "Stand": 12.25}
 
print("Receipt")
for name, price in items.items():
    print(f"{name}: ${price:.2f}")
 
print(f"Total: ${sum(items.values()):.2f}")
input("Press Enter to close...")

Se você já tem o Python instalado, teste o código antes de empacotar:

python receipt.py

O total deve ser Total: $40.00. Aperte Enter para encerrar. Nosso guia para executar scripts Python explica como configurar o terminal, caso este seja o seu primeiro script.

Adicione o projeto e faça o build

1. Abra o conversor de Python para EXE do Runcell (opens in a new tab) e vá até o conversor na página.
2. Escolha o arquivo receipt.py. Para uma aplicação de console que já existe, selecione a pasta do projeto ou o ZIP, incluindo os módulos e recursos que ela usa.
3. Selecione receipt.py como script de entrada. Em um projeto maior, é o script que você normalmente executa para iniciar a aplicação, como main.py.
4. Revise os imports, as dependências e os arquivos incluídos que o conversor detectou. O exemplo do recibo não precisa de pacotes adicionais. No seu app, confira se os recursos necessários e as versões dos pacotes batem com o projeto que você pretende distribuir. O runtime do Runcell é o Python 3.14, então cada pacote precisa de um wheel que funcione no Windows com Python 3.14 (um wheel cp314, abi3 ou em Python puro).
5. Selecione Build Windows EXE e baixe o executável gerado. Abra no Windows e confira a saída do recibo antes de compartilhar.

No nosso teste no navegador, o Runcell gerou e baixou receipt.exe. O cabeçalho do arquivo o identifica como um executável Windows x64. Não executamos esse EXE no Windows.

Em projetos com vários arquivos, mantenha a estrutura de pastas intacta. Um template carregado de templates/invoice.html precisa ser incluído no caminho que a sua aplicação espera.

Como um navegador gera um EXE para Windows

O motor de empacotamento próprio do Runcell combina um launcher de Windows pré-compilado, um runtime Python, os arquivos do seu projeto e as dependências. Ele monta esses componentes em um .exe para download, no seu dispositivo. Como os componentes de Windows já vêm compilados, o navegador consegue montar o binário final sem rodar um compilador de Windows localmente.

O fluxo tem duas etapas separadas:

Your Python project + dependencies
                +
Python runtime + precompiled Windows launcher
                |
                v
Runcell assembles the EXE in your browser
                |
                v
Download the file, then run it on Windows

Gerar um arquivo e executá-lo são operações diferentes: o navegador monta o executável, e o Windows roda a aplicação pronta. O guia do mecanismo do Runcell (opens in a new tab) descreve esse caminho de empacotamento.

O que fica no seu dispositivo

O Runcell faz o build do EXE no seu navegador. Se o seu projeto importa um módulo que o runtime de Windows embutido não inclui, o conversor avisa antes do build; remova esse import ou use um dos empacotadores locais abaixo.

O seu código-fonte e os seus segredos ficam no seu dispositivo durante o build. O EXE final contém o seu código, então não empacote segredos que você não compartilharia.

Método 2: build local com PyInstaller

O PyInstaller (opens in a new tab) reúne o seu script, os imports dele e o runtime Python em uma aplicação distribuível. Para gerar um EXE de Windows, rode o PyInstaller no Windows: ele gera builds para o sistema operacional em que está rodando.

Abra o PowerShell na pasta que contém receipt.py. Crie um ambiente virtual e instale o PyInstaller nele. Se você instalou o Python pelo python.org, o launcher py funciona mesmo quando python não está no PATH, e chamar diretamente o Python do ambiente dispensa a etapa de ativação:

py -m venv .venv
.\.venv\Scripts\python.exe -m pip install pyinstaller
.\.venv\Scripts\python.exe -m PyInstaller --onefile receipt.py

O resultado é dist\receipt.exe. Rode pelo PowerShell para ver a saída:

.\dist\receipt.exe

No seu próprio projeto, instale as dependências no mesmo ambiente antes do build. Se ele tiver um requirements.txt, use .\.venv\Scripts\python.exe -m pip install -r requirements.txt.

A chamada -m PyInstaller, que diferencia maiúsculas de minúsculas, está documentada no guia de instalação (opens in a new tab). Ela mantém o empacotador e as suas dependências no mesmo ambiente Python.

Escolha console, GUI ou build em pasta

Mantenha o modo console para receipt.py, porque ele usa print() e input(). Para uma aplicação gráfica que faz toda a interação nas próprias janelas, --windowed esconde o console. Comece com --onedir quando quiser inspecionar a aplicação e os arquivos de apoio em uma pasta, e depois use --onefile para ter um único arquivo para download. Veja a referência de opções do PyInstaller (opens in a new tab).

Para incluir uma pasta assets, adicione-a explicitamente:

.\.venv\Scripts\python.exe -m PyInstaller --onefile --add-data "assets:assets" receipt.py

Esse exemplo pressupõe que você criou uma pasta assets. Para arquivos somente leitura empacotados, resolva os caminhos em relação a __file__, como descrito no guia de runtime do PyInstaller (opens in a new tab). Nosso guia de pathlib no Python explica as operações com caminhos.

Método 3: compilar e empacotar com Nuitka

O Nuitka (opens in a new tab) compila Python e pode criar aplicações distribuíveis. Escolha-o quando quiser controle sobre um build baseado em compilador. Você precisa de um compilador C compatível; no Windows, o manual cita o Visual Studio 2022 ou mais novo como uma das opções. O manual também diz que o MinGW64 não funciona com Python 3.13 ou mais novo sem uma flag experimental, então, em um Python atual, planeje instalar o Visual Studio Build Tools.

Em um ambiente virtual do mesmo tipo, instale o Nuitka e peça o modo de arquivo único (one-file):

py -m venv .venv
.\.venv\Scripts\python.exe -m pip install nuitka
.\.venv\Scripts\python.exe -m nuitka --mode=onefile receipt.py

A saída esperada no Windows é receipt.exe. Use --mode=standalone se preferir uma pasta de distribuição. Defina um desses modos explicitamente: o modo padrão do Nuitka, o accelerated, não serve para distribuir uma aplicação para uma máquina sem Python. Siga o manual oficial para configurar o compilador e as opções específicas de cada pacote.

Método 4: criar uma pasta de aplicação com cx_Freeze

O cx_Freeze (opens in a new tab) normalmente gera uma pasta com o executável e as bibliotecas de apoio. Escolha-o quando quiser manter um build de aplicação configurado e distribuir a pasta inteira.

Em um ambiente virtual do mesmo tipo, instale o pacote e rode o builder de linha de comando:

py -m venv .venv
.\.venv\Scripts\python.exe -m pip install cx-Freeze
.\.venv\Scripts\cxfreeze.exe --script receipt.py --target-dir dist

Isso segue a referência atual do comando cxfreeze (opens in a new tab). Distribua a pasta dist completa, com as bibliotecas, em vez de copiar só o EXE. Para configurações de projeto repetíveis, o cx_Freeze também aceita pyproject.toml e um script de setup em Python.

Teste o resultado antes de compartilhar

Rode a aplicação em uma máquina Windows parecida com a dos seus destinatários. Neste exemplo, confira os preços dos itens, o total de $40.00 e o aviso para apertar Enter. Uma máquina sem uma instalação separada do Python é um bom teste para saber se você incluiu o runtime e as dependências.

Em um app maior, teste a ação de que o destinatário realmente precisa, como selecionar um arquivo de entrada e salvar um relatório. Se a janela do console fechar na hora, abra o EXE pelo PowerShell para ler o erro. Se faltar uma imagem ou um template, confira tanto os arquivos empacotados quanto o caminho usado para carregá-los. Imports dinâmicos podem precisar ser incluídos explicitamente com as opções do empacotador local.

EXEs sem assinatura, gerados por qualquer uma dessas ferramentas, podem disparar um aviso do Microsoft Defender SmartScreen na primeira vez que alguém os abre. O destinatário seleciona More info e depois Run anyway (no Windows em português: “Mais informações” e “Executar assim mesmo”).

Perguntas frequentes

Como converter um arquivo .py em .exe sem instalar um empacotador?

Use o conversor de Python para EXE do Runcell (opens in a new tab). Escolha o arquivo Python, a pasta ou o ZIP, selecione o script de entrada, revise as dependências e faça o build do EXE para Windows pelo navegador.

Um navegador consegue mesmo gerar um executável do Windows?

Sim. O Runcell monta componentes de Windows pré-compilados, um runtime Python e a sua aplicação em um EXE, no navegador. Você baixa esse arquivo e o executa no Windows. O navegador não precisa executar a aplicação de Windows para gerar o binário dela.

Quem vai rodar o EXE precisa ter o Python instalado?

Não é preciso uma instalação separada do Python quando você distribui a aplicação com o runtime e as dependências necessárias. O Runcell inclui o runtime no fluxo de empacotamento. Em um build em pasta feito com uma ferramenta local, compartilhe a pasta de saída completa.

Qual é o comando do PyInstaller para gerar um único EXE?

Rode python -m PyInstaller --onefile receipt.py no ambiente Windows em que o PyInstaller e as dependências do seu projeto estão instalados. A saída do exemplo é dist\receipt.exe.

Fontes e testes

O fluxo do Runcell e o mecanismo de empacotamento seguem o guia público do produto (opens in a new tab), consultado em 4 de novembro de 2026. Os comandos de build local seguem a documentação oficial indicada em cada método. Rodamos o script de exemplo do recibo no macOS, selecionamos o arquivo no conversor online do Runcell, geramos e baixamos receipt.exe e inspecionamos o cabeçalho PE de Windows x64. No macOS, também fizemos o build do script do recibo com PyInstaller 6.22.3 (--onefile) e cx_Freeze 8.7.4 para checar esses comandos, e conferimos as opções de modo do Nuitka na saída de ajuda dele. Nenhum EXE foi executado no Windows para este artigo.

Guias relacionados

• Como executar scripts Python
• Ambientes virtuais em Python
• Python pathlib para caminhos de arquivos e recursos
• Python argparse para entradas de linha de comando