nuitka: The python compiler

SYNOPSIS

nuitka [\,--module\/] [\,--execute\/] [\,options\/] \,main_module.py\/

OPTIONS

--version: show program's version number and exit
-h, --help: show this help message and exit
--module: Create an extension module executable instead of a program. Defaults to off.
--standalone, --portable: Enable standalone mode in build. This allows you to transfer the created binary to other machines without it relying on an existing Python installation. It implies these options: "--recurse-all --recursestdlib". Defaults to off.
--nofreeze-stdlib: In standalone mode by default all modules of standard library will be frozen as bytecode. As a result compilation time will increase very much.
--python-version=\,PYTHON_VERSION\/: Major version of Python to be used, one of '2.6', '2.7', '3.2', '3.3', or '3.4'. Defaults to what you run Nuitka with.
--python-debug, --python-dbg: Use debug version or not. Default uses what you are using to run Nuitka, most likely a non-debug version.
--python-flag=\,PYTHON_FLAGS\/: Python flags to use. Default uses what you are using to run Nuitka, this enforces a specific mode. These are options that also exist to standard Python executable. Currently supported: "-S" (alias nosite), "static_hashes" (not use Randomization), "no_warnings" (do not give Python runtime warnings). Default empty.
--warn-implicit-exceptions: Given warnings for implicit exceptions detected at compile time.

Control the recursion into imported modules:

--recurse-stdlib: Also descend into imported modules from standard library. Defaults to off.
--recurse-none: When --recurse-none is used, do not descend into any imported modules at all, overrides all other recursion options. Defaults to off.
--recurse-all, --recurse-on: When --recurse-all is used, attempt to descend into all imported modules. Defaults to off.
--recurse-to=\,MODULE\//PACKAGE: Recurse to that module, or if a package, to the whole package. Can be given multiple times. Default empty.
--recurse-not-to=\,MODULE\//PACKAGE: Do not recurse to that module, or if a package, to the whole package in any case, overrides all other options. Can be given multiple times. Default empty.
--recurse-plugins=\,MODULE\//PACKAGE, --recurse-directory=\,MODULE\//PACKAGE: Recurse into that directory, no matter if it's used by the given main program in a visible form. Overrides all other options. Can be given multiple times. Default empty.

Immediate execution after compilation:

--run, --execute: Execute immediately the created binary (or import the compiled module). Defaults to off.
--execute-with-pythonpath, --keep-pythonpath: When immediately executing the created binary (--execute), don't reset PYTHONPATH. When all modules are successfully included, you ought to not need PYTHONPATH anymore.

Dump options for internal tree:

--dump-xml, --xml: Dump the final result of optimization as XML, then exit.
--display-tree: Display the final result of optimization in a GUI, then exit.

Code generation choices:

--improved, --enhanced: Allow minor devitations from CPython behaviour, e.g. better tracebacks, which are not really incompatible, but different.
--code-gen-no-statement-lines: Statements shall have their line numbers set. Disable this for less precise exceptions and slightly faster code. Not recommended. Defaults to off.

Output directory choices:

--output-dir=\,DIRECTORY\/: Specify where intermediate and final output files should be put. DIRECTORY will be populated with C++ files, object files, etc. Defaults to current directory.
--remove-output: Removes the build directory after producing the module or exe file. Defaults to off.

Debug features:

--debug: Executing all self checks possible to find errors in Nuitka, do not use for production. Defaults to off.
--unstripped, --no-strip, --unstriped: Keep debug info in the resulting object file for better gdb interaction. Defaults to off.
--trace-execution: Traced execution output, output the line of code before executing it. Defaults to off.
--c++-only: Compile the would-be regenerated source file. Allows compiling edited C++ files with the C++ compiler for quick debugging changes to the generated source. Defaults to off.
--experimental: Use features declared as 'experimental'. May have no effect if no experimental features are present in the code. Defaults to off.

Backend C++ compiler choice:

--clang: Enforce the use of clang (needs clang 3.2 or higher). Defaults to off.
--mingw: Enforce the use of MinGW on Windows. Defaults to off.
--msvc=\,MSVC\/: Enforce the use of specific MSVC version on Windows. Allowed values are e.g. 9.0, 9.0exp, specify an illegal value for a list of installed compilers. Defaults to the most recent version.
-j N, --jobs=\,N\/: Specify the allowed number of parallel C++ compiler jobs. Defaults to the system CPU count.
--lto: Use link time optimizations if available and usable (g++ 4.6 and higher). Defaults to off.

Tracing features:

--show-scons: Operate Scons in non-quiet mode, showing the executed commands. Defaults to off.
--show-progress: Provide progress information and statistics. Defaults to off.
--show-modules: Provide a final summary on included modules. Defaults to off.
--verbose: Output details of actions take, esp. in optimizations. Can become a lot. Defaults to off.

Windows specific output control::

--windows-disable-console: When compiling for windows, disable the console window. Defaults to off.
--windows-icon=\,ICON_PATH\/, --icon=\,ICON_PATH\/: Add executable icon (windows only).

EXAMPLES

Compile a python file "some_module.py" to a module "some_module.so":

$ nuitka some_module.py

Compile a python program "some_program.py" to an executable "some_program.exe":

$ nuitka --exe some_program.py

Compile a python program "some_program.py" and the package "some_package" it uses to an executable "some_program.exe":

$ nuitka --exe --recurse-to=some_package some_program.py

Compile a python program "some_program.py" and all the modules it uses to an executable "some_program.exe". Then execute it immediately when ready:

$ nuitka --exe --execute --recurse-all some_program.py

Compile a python program "some_program.py" and the modules it uses (even standard library) to an executable "some_program.exe":

$ nuitka --recurse-all --recurse-stdlib some_program.py --exe

Compile a python program "some_program.py" and the modules it uses to an executable "some_program.exe". Keep the debug information, so valrind, gdb, etc. work nice.

Note: This will *not* degrade performance:

$ nuitka --unstriped --recurse-all some_program.py --exe

Compile a python program "some_program.py" and the modules it uses to an executable "some_program.exe". Perform all kinds of checks about correctness of the generated C++ and run-time checks.

Note: This will degrade performance and should only be used to debug Nuitka:

$ nuitka --debug --recurse-all some_program.py --exe

Compile a python program "some_program.py" and the modules it uses to an executable "some_program.exe". Perform all kinds of checks about correctness of the generated C++ and run-time checks. Also use the debug Python library, which does its own checks.