Skip to content

Nuitka

by Tim Hopper
Packaging

Nuitka is a Python-to-C compiler that translates CPython bytecode into C source, then compiles and links the result against libpython. The output runs without a separate Python installation and can ship as a standalone folder, a self-extracting single-file executable, or an importable extension module. Nuitka runs on Linux, macOS, and Windows; the build machine needs a C toolchain (gcc, clang, or MSVC). Install it with uv tool install nuitka or pipx install nuitka. Nuitka is AGPL-3.0+ with a runtime exception for compiled output, so the license does not carry over to the applications it produces.

Key Features

  • Full-program compilation from Python source to a native executable
  • Acceleration mode for compiling a single module in place
  • --mode=standalone for a self-contained folder of binaries and data
  • --mode=onefile for a single self-extracting binary
  • --mode=module for producing importable .so or .pyd extensions
  • --mode=app for macOS .app bundles
  • Plugin system with package-specific configs for NumPy, SciPy, scikit-learn, PyTorch, and TensorFlow
  • Link-time optimization (LTO) and profile-guided optimization (PGO) toggles

How Nuitka Works

Nuitka departs from the freezer model used by PyInstaller and cx_Freeze. Those tools ship the original .pyc files plus a bootloader. Nuitka instead generates C source code that calls libpython through the CPython C API, then compiles that source with gcc, clang, or MSVC.

The result is a native binary that embeds compiled program logic rather than shipping the original .pyc files in a bootloader bundle. Import statements resolve at compile time, and C compilation can drop unused attributes and fold constants. Recovering source-level logic from the binary is harder than extracting bundled .pyc files, which is the main reason teams choose Nuitka over a freezer.

Compilation is slower than bundling. A medium-size application that PyInstaller packages in 30 seconds can take 5 to 15 minutes in Nuitka because every module passes through a C compiler. Output binaries are also larger than PyInstaller equivalents on the same input.

Performance

Nuitka’s published Python 2.7 pystone benchmark reports 3.353× CPython performance with LTO and 3.663× with PGO. Those numbers come from a microbenchmark, not general application throughput. CPU-bound pure-Python workloads may improve by roughly 10% to 40% in practice, while I/O-heavy or C-extension-heavy programs often see little change. Nuitka is a compile-ahead-of-time packager that happens to produce faster code, not a drop-in JIT replacement.

Machine learning packages

Recent releases added built-in package-specific rules for PyTorch, TensorFlow, scikit-learn, and SciPy. The rules prune unused operator kernels and skip compiling TensorFlow’s generated code, which was previously a build-time blocker. ML projects still need the right plugin enabled for each framework, and not every model-serving stack compiles cleanly on the first try.

Antivirus false positives

Onefile binaries trigger the same false positives that affect PyInstaller and cx-freeze. The self-extracting stub looks like a dropper to signature-based scanners. Code signing on macOS and Windows, plus submitting binaries to Microsoft and vendor allowlists, remains part of a production distribution pipeline.

Commercial Edition

Nuitka ships a paid tier alongside the AGPL community edition:

  • Nuitka Commercial (€250 per year): constant and data-file obfuscation, encrypted tracebacks, protection against runtime DLL and extension-module swapping, Windows 7 and XP targets, RHEL 7 portable builds, Windows Service deployment, and access to commercial-only package configs like legacy PySide2.
  • Full Package (€400 per year): Nuitka Commercial plus priority support.

The commercial source code cannot be redistributed. Compiled output can be shipped without per-seat runtime limits, and that right survives the subscription ending. Confirm current pricing and scope at nuitka.net/doc/commercial.html before purchase.

Pros

  • Produces a native binary with source-code protection beyond bytecode obscurity
  • Faster runtime than CPython on CPU-bound pure-Python code
  • Standalone, onefile, module, and macOS app-bundle targets from one tool
  • Active maintenance with a commercial support track
  • Built-in configs for the packages that most often break bundlers (PyTorch, TensorFlow, SciPy)

Cons

  • Build times of minutes, not seconds, on non-trivial applications
  • Larger output than PyInstaller for equivalent inputs
  • AGPL-3.0 requires care when integrating the tool itself into proprietary build systems; the runtime exception covers the generated binary
  • ML frameworks need the right plugin, and new package versions occasionally break until a config lands
  • Antivirus false positives on unsigned onefile binaries require the same signing and reputation work as any other freezer

Learn More

Last updated on
noxpdb

Please submit corrections and feedback...