Intro to Nuitka: A greater option to compile and distribute Python

As Python’s recognition rises, its limitations have gotten extra clear. For one factor, it may be very arduous to put in writing a Python utility and distribute it to individuals who do not have Python put in.

The most typical option to clear up this challenge is to package deal this system along with all its supporting libraries and recordsdata and the Python runtime. There are instruments for doing this, like PyInstaller, however they require a number of cadging to work accurately. What’s extra, it is usually doable to extract the supply code for the Python program from the ensuing package deal. For some eventualities, that is a deal breaker.

Nuitka, a third-party undertaking, affords a radical answer. It compiles a Python program to a C binary—not by packaging the CPython runtime with this system bytecode, however by translating Python directions into C. The outcomes will be distributed in a zipped bundle or packaged into an installer with one other third-party product.

Nuitka additionally tries to keep up most compatibility with the Python ecosystem, so third-party libraries like NumPy work reliably. Nuitka additionally tries to make efficiency enhancements to compiled Python applications each time doable, however once more with out sacrificing general compatibility. Speedups aren’t assured, both—they range tremendously between workloads, and a few applications won’t expertise any vital efficiency enchancment. As a basic rule, it is best to not depend on Nuitka to enhance efficiency, however moderately as a bundling answer.

Putting in Nuitka

Nuitka works with Python 2.6 by way of 2.7 and Python 3.3 by way of 3.10. It may compile binaries for Microsoft Home windows, macOS, Linux, and FreeBSD/NetBSD. Observe that you need to construct the binaries on the goal platform; you can not cross-compile.

For each platform, except for needing the Python runtime, you will additionally want a C compiler. On Microsoft Home windows, Visible Studio 2022 or greater is really useful, however additionally it is doable to make use of MinGW-w64 C11 (gcc 11.2 or greater). For different platforms, you should utilize gcc 5.1 or greater, g++ 4.4 or greater, clang, or clang-cl on Home windows underneath Visible Studio.

Observe that when you use Python 3.3 or Python 3.4 (that are lengthy deprecated), you will want Python 2.7 due to software dependencies. All of this needs to be an argument to make use of the latest model of Python when you can.

It is best to put in Nuitka in a digital atmosphere alongside along with your undertaking as a improvement dependency moderately than a distribution dependency. Nuitka itself is not bundled with or utilized by your undertaking; it performs the bundling.

Utilizing Nuitka for the primary time

Upon getting Nuitka put in, use nuitka, or python -m nuitka to invoke it.

The very first thing you will wish to do with Nuitka is to confirm the whole toolchain works, together with your C compiler. To check this, you may compile a easy “Hey world” Python program—name it important.py:

print ("Hey world")

While you compile a Python program with Nuitka, you cross the identify of the entry-point module as a parameter to Nuitka, for instance, nuitka important.py. When invoked like this, Nuitka will soak up important.py and construct a single executable from it.

Observe that as a result of we’re simply testing out Nuitka’s performance, it’s going to solely compile that one Python file to an executable. It won’t compile the rest, nor will it bundle something for redistribution. However compiling one file needs to be sufficient to find out if Nuitka’s toolchain is about up accurately.

As soon as the compilation finishes, you need to see a binary executable file positioned in the identical listing because the Python program. Run the executable to make sure it really works.

You can too robotically run your Nuitka-compiled app by passing --run as a command-line flag.

In case your “Hey world” take a look at executable works, you may attempt packaging it as a redistributable. I am going to clarify that course of shortly.

Observe that whenever you run your first take a look at compilation with Nuitka, it’s going to most likely full in a matter of seconds. Do not be fooled by this! Proper now, you’re solely compiling a single module, not your whole program. Compiling a full program with Nuitka can take many minutes or longer, relying on what number of modules this system makes use of.

Compile a Python program with Nuitka

By default, Nuitka solely compiles the module you specify. In case your module has imports—whether or not from elsewhere in your program, from the usual library, or from third-party packages—you will have to specify that these needs to be compiled, too.

Think about a modified model of the “Hey world” program, the place you might have an adjoining module named greet.py:

def greet(identify):
    print ("Hey ", identify)

and a modified important.py:

import greet
greet.greet("world")

To have each modules compiled, you should utilize the --follow-imports swap:

nuitka --follow-imports important.py

The swap ensures that each one the imports required all through this system are traced from the import statements and compiled collectively.

Another choice, --nofollow-import-to, allows you to exclude particular subdirectories from the import course of. This selection is beneficial for screening out take a look at suites, or modules that are by no means used. It additionally allows you to provide a wildcard as an argument.

IDG

Embody dynamic imports

Now comes one of many wrinkles Python customers usually confront when making an attempt to package deal a Python utility for distribution. The --follow-imports possibility solely follows imports explicitly declared in code by means of an import assertion. It would not deal with dynamic imports.

To get round this, you should utilize the --include-plugin-directory swap to supply a number of paths to modules which can be dynamically imported. As an example, for a listing named mods that accommodates dynamically imported code, you’d use:

nuitka --follow-imports --include-plugin-directory=mods important.py

Embody knowledge recordsdata and directories

In case your Python program makes use of knowledge recordsdata loaded at runtime, Nuitka cannot robotically detect these, both. To incorporate particular person recordsdata and directories with a Nuitka-packaged program, you’d use --include-data-files and --include-data-dir.

--include-data-files allows you to specify a wildcard for the recordsdata to repeat and the place you need them copied to. As an example, --include-data-files=/knowledge/*=knowledge/ takes all of the recordsdata that match the wildcard knowledge/* and copies them to knowledge/ in your distribution listing.

--include-data-dir works roughly the identical method, besides that it makes use of no wildcard; it simply allows you to cross a path to repeat and a vacation spot within the distribution folder to repeat it to. For example, --include-data-dir=/path/to/knowledge=knowledge would copy every thing in /path/to/knowledge to the matching listing knowledge in your distribution listing.

Embody Python packages and modules

One other option to specify imports is through the use of a Python-style package deal namespace moderately than a file path, utilizing the --include-package possibility. As an example, the next command would come with mypackage, wherever it’s on disk (assuming Python may find it), and every thing beneath it:

nuitka --include-package=mypackage important.py

If packages require their very own knowledge recordsdata, you may embrace these with the --include-package-data possibility:

nuitka --include-package=mypackage --include-package-data=mypackage important.py

This command tells Nuitka to select up any recordsdata within the package deal listing that are not truly code.

Should you solely wish to embrace a single module, you should utilize --include-module:

nuitka --include-module=mypackage.mymodule important.py

This command tells Nuitka to incorporate solely mypackage.mymodule, however nothing else.

Compile a Python program for redistribution

While you wish to compile a Python program with Nuitka for redistribution, you should utilize a command-line swap, --standalone, that handles a lot of the work. This swap robotically follows all imports and generates a dist folder that features the compiled executable and any assist recordsdata wanted. To redistribute this system, you solely want to repeat this listing.

Do not count on a --standalone-compiled program to work the primary time you run it. The overall dynamism of Python applications all however ensures you will want to make use of among the different above-described choices to make sure the compiled program runs correctly. As an example, you probably have a GUI app that requires particular fonts, you’ll have to repeat them into your distribution with --include-data-files or --include-data-dir.

Additionally, as famous above, the compilation time for a --standalone utility could also be considerably longer than for a take a look at compilation. Finances within the wanted construct time for testing a standalone-built utility after you have some concept of how lengthy it’s going to take.

Lastly, Nuitka affords one other construct possibility, --onefile. For these aware of PyInstaller, --onefile works the identical method as the identical possibility in that program: it compresses your whole utility, together with all its dependent recordsdata, right into a single executable with no different recordsdata wanted for redistribution. Nonetheless, you will need to know that --onefile works otherwise on Linux and Microsoft Home windows. On Linux, it mounts a digital filesystem with the contents of the archive. On Home windows, it unpacks the recordsdata into a brief listing and runs them from there—and it has to do that for every run of this system. Utilizing --onefile on Home windows could considerably decelerate the time it takes to begin this system.