How can I make a Python script standalone executable to run without ANY dependency?


I’m building a Python application and don’t want to force my clients to install Python and modules.

So, is there a way to compile a Python script to be a standalone executable?

Asked By: Jeff



You may like py2exe. You’ll also find information in there for doing it on Linux.

Answered By: user237419

You can use PyInstaller to package Python programs as standalone executables. It works on Windows, Linux, and Mac.

PyInstaller Quickstart

Install PyInstaller from PyPI:

pip install pyinstaller

Go to your program’s directory and run:


This will generate the bundle in a subdirectory called dist.

pyinstaller -F

Adding -F (or –onefile) parameter will pack everything into single "exe".

pyinstaller -F --paths=<your_path>Libsite-packages

running into "ImportError" you might consider side-packages.

 pip install pynput==1.6.8

still runing in Import-Erorr – try to downgrade pyinstaller – see Getting error when using pynput with pyinstaller

For a more detailed walkthrough, see the manual.

Answered By: Rumple Stiltskin

And a third option is cx_Freeze, which is cross-platform.

Answered By: Katriel

You can use py2exe as already answered and use Cython to convert your key .py files in .pyc, C compiled files, like .dll in Windows and .so on Linux.

It is much harder to revert than common .pyo and .pyc files (and also gain in performance!).

Answered By: neurino

For Python 3.2 scripts, the only choice is cx_Freeze. Build it from sources; otherwise it won’t work.

For Python 2.x I suggest PyInstaller as it can package a Python program in a single executable, unlike cx_Freeze which outputs also libraries.

Answered By: ravi.chunduru

I also recommend PyInstaller for better backward compatibility such as Python 2.3 – 2.7.

For py2exe, you have to have Python 2.6.

Answered By: yantaq

You might wish to investigate Nuitka. It takes Python source code and converts it in to C++ API calls. Then it compiles into an executable binary (ELF on Linux). It has been around for a few years now and supports a wide range of Python versions.

You will probably also get a performance improvement if you use it. It is recommended.

Answered By: cdarke

Use py2exe…. use the below set up files:

from distutils.core import setup
import py2exe

from distutils.filelist import findall
import matplotlib

    console = [''],

    options = {
        'py2exe': {
            'packages': ['matplotlib'],
            'dll_excludes': ['libgdk-win32-2.0-0.dll',
    data_files = matplotlib.get_py2exe_datafiles()
Answered By: Anand

py2exe will make the EXE file you want, but you need to have the same version of MSVCR90.dll on the machine you’re going to use your new EXE file.

See Tutorial for more information.

Answered By: Belial

You can find the list of distribution utilities listed at Distribution Utilities.

I use bbfreeze and it has been working very well (yet to have Python 3 support though).

Answered By: Joe

I would like to compile some useful information about creating standalone files on Windows using Python 2.7.

I have used py2exe and it works, but I had some problems.

This last reason made me try PyInstaller

In my opinion, it is much better because:

  • It is easier to use.

I suggest creating a .bat file with the following lines for example (pyinstaller.exe must be in in the Windows path):

pyinstaller.exe --onefile

So, I think that, at least for python 2.7, a better and simpler option is PyInstaller.

Answered By: Diego

Not exactly a packaging of the Python code, but there is now also Grumpy from Google, which transpiles the code to Go.

It doesn’t support the Python C API, so it may not work for all projects.

Answered By: freeformz

Use Cython to convert to C, compile, and link with GCC.

Another could be, make the core functions in C (the ones you want to make hard to reverse), compile them and use Boost.Python to import the compiled code (plus you get a much faster code execution). Then use any tool mentioned to distribute.

Answered By: F.Moure

Yes, it is possible to compile Python scripts into standalone executables.

PyInstaller can be used to convert Python programs into stand-alone executables, under Windows, Linux, Mac OS X, FreeBSD, Solaris, and AIX. It is one of the recommended converters.

py2exe converts Python scripts into only executable on the Windows platform.

Cython is a static compiler for both the Python programming language and the extended Cython programming language.

Answered By: fury.slay

I’m told that PyRun is also an option. It currently supports Linux, FreeBSD and Mac OS X.

Using PyInstaller, I found a better method using shortcut to the .exe rather than making --onefile. Anyway, there are probably some data files around and if you’re running a site-based app then your program depends on HTML, JavaScript, and CSS files too. There isn’t any point in moving all these files somewhere… Instead what if we move the working path up?

Make a shortcut to the EXE file, move it at top and set the target and start-in paths as specified, to have relative paths going to distfolder:

Target: %windir%system32cmd.exe /c start distweb_wrapperweb_wrapper.exe
Start in: "%windir%system32cmd.exe /c start distweb_wrapper"

We can rename the shortcut to anything, so renaming to "GTFS-Manager".
Now when I double-click the shortcut, it’s as if I python-ran the file! I found this approach better than the --onefile one as:

  1. In onefile’s case, there’s a problem with a .dll missing for the Windows 7 OS which needs some prior installation, etc. Yawn. With the usual build with multiple files, no such issues.
  2. All the files that my Python script uses (it’s deploying a tornado web server and needs a whole freakin’ website worth of files to be there!) don’t need to be moved anywhere: I simply create the shortcut at top.
  3. I can actually use this exact same folder on Ubuntu (run python3 and Windows (double-click the shortcut).
  4. I don’t need to bother with the overly complicated hacking of .spec file to include data files, etc.

Oh, remember to delete off the build folder after building. It will save on size.

Answered By: Nikhil VJ

I like PyInstaller – especially the "windowed" variant:

pyinstaller --onefile --windowed

It will create one single *.exe file in a distination/folder.

Answered By: cslotty
pyinstaller -F --onefile

This creates a standalone EXE file on Windows.

Important note 1: The EXE file will be generated in a folder named ‘dist’.

Important note 2: Do not forget –onefile flag

You can install PyInstaller using pip install PyInstaller

Enter image description here

Enter image description here

NOTE: In rare cases there are hidden dependencies…so if you run the EXE file and get missing library error (win32timezone in the example below) then use something like this:

pyinstaller --hiddenimport win32timezone -F "Backup"
Answered By: Chadee Fouad

Since it seems to be missing from the current list of answers, I think it is worth mentioning that the standard library includes a zipapp module that can be used for this purpose. Its basic usage is just compressing a bunch of Python files into a zip file with extension .pyz than can be directly executed as python myapp.pyz, but you can also make a self-contained package from a requirements.txt file:

$ python -m pip install -r requirements.txt --target myapp
$ python -m zipapp -p "interpreter" myapp

Where interpreter can be something like /usr/bin/env python (see Specifying the Interpreter).

Usually, the generated .pyz / .pyzw file should be executable, in Unix because it gets marked as such and in Windows because Python installation usually registers those extensions. However, it is relatively easy to make a Windows executable that should work as long as the user has python3.dll in the path.

If you don’t want to require the end user to install Python, you can distribute the application along with the embeddable Python package.

Answered By: jdehesa
Categories: questions Tags: ,
Answers are sorted by their score. The answer accepted by the question owner as the best is marked with
at the top-right corner.