5 Best Ways to Compile a Python 3 App to an EXE Using Tkinter

Rate this post

πŸ’‘ Problem Formulation: Python developers often create applications with graphical user interfaces (GUIs) using the Tkinter module. However, sharing these Python applications with end users presents a challenge, as recipients must have the Python interpreter installed to run the scripts. This article addresses the issue by providing methods to convert a Python 3 Tkinter app into a standalone executable (.exe) file, enabling the app to run on any Windows computer without requiring Python installation. Suppose our input is a Python file app.py containing a Tkinter application; the desired output is a single app.exe file that can be executed independently.

Method 1: Using PyInstaller

This method involves using PyInstaller, a well-supported tool that can convert Python applications into standalone executables, under Windows, macOS, and Linux. It analyzes your Python programs to discover every other module and file your program needs to run. Then it collects copies of all those files, including the active Python interpreter, and bundles them into a single package.

Here’s an example:

pyinstaller --onefile --windowed myapp.py

This command should produce a single executable file in the dist folder.

By running the PyInstaller command, you create a bundled single-file executable. The --onefile option tells PyInstaller to pack everything into one executable file, whereas --windowed indicates that the application should not run in a console window, suitable for GUI applications created with Tkinter.

Method 2: Using cx_Freeze

cx_Freeze is another tool to create standalone executables from Python scripts, similar to PyInstaller but with a different approach in freezing applications. It officially supports Python versions 3.5 through 3.9.

Here’s an example:

from cx_Freeze import setup, Executable

    name = "MyApp",
    version = "0.1",
    description = "My GUI application!",
    executables = [Executable("MyApp.py", base="Win32GUI")]

After defining the setup script, run python setup.py build to create the executable.

The code provided is a setup script for cx_Freeze. By specifying base="Win32GUI", you tell cx_Freeze that the application should not run in a console window, which is optimal for Tkinter applications.

Method 3: Using Py2exe

Py2exe is a popular tool for converting Python scripts into Windows executables. It is designed specifically for Windows and does not support other operating systems. It works by creating a distribution that contains all the necessary files, modules, and libraries required to run the application.

Here’s an example:

from distutils.core import setup
import py2exe

    windows = [{'script': "myapp.py"}],
    zipfile = None,

Run python setup.py py2exe to produce the EXE.

This snippet outlines a setup file for Py2exe. Running the setup file with Py2exe as the target will compile your Tkinter application into an executable. The zipfile = None option will embed DLLs and Python interpreter into the exe, instead of as a separate zip file.

Method 4: Using Auto Py To Exe

Auto Py To Exe is a graphical interface for PyInstaller. It provides a more user-friendly way to package Python scripts into executables using PyInstaller’s functionality through a graphical interface instead of the command line.

Here’s an example:

# No code example is needed here as this method uses a GUI.

Launch the ‘Auto Py to Exe’ application and fill out the form to provide the parameters you would usually write in the command line. Click ‘Convert .py to .exe’ to create the executable.

This application wraps PyInstaller in a GUI, developed using Tkinter itself. It provides a convenient drag-and-drop or browse option to select your Python script, lets you add icons, and you can customize the executable to be onefile or not and to be windowed or console based.

Bonus One-Liner Method 5: Using Nuitka

Nuitka is a Python compiler written in Python. It’s fully compatible with Python 2 and Python 3, allowing applications to be translated into C++ and then compiled into an executable. This can provide a performance improvement as well as executable generation.

Here’s an example:

python -m nuitka --follow-imports --onefile --windowed myapp.py

Run the command to compile your Tkinter application into an EXE file with Nuitka.

This command uses Nuitka to convert the Python script into C++ code and then compile it into a single-file executable. The --follow-imports option tells Nuitka to include imported modules in the compilation process. The --onefile and --windowed options serve the same purpose as in PyInstaller, packaging into a single file and indicating a GUI application respectively.


  • Method 1: PyInstaller. Popular due to its simplicity and cross-platform support. However, the resulting executables can be large in size and sometimes trigger antivirus false positives.
  • Method 2: cx_Freeze. A good alternative to PyInstaller, especially when dealing with complex dependencies. Not as widely used as PyInstaller and may have a steeper learning curve.
  • Method 3: Py2exe. A reliable Windows-only solution that has been around for a long time. One of its drawbacks is the lack of support for the latest Python versions and limited operating system support.
  • Method 4: Auto Py To Exe. Offers a user-friendly GUI for PyInstaller. Excellent for those less comfortable with command-line operations. However, it may not offer as much flexibility as direct use of PyInstaller.
  • Method 5: Nuitka. Provides the benefit of performance optimization along with executable generation. However, the compilation process can be slow and the tool can be complex for new users.