All Versions
Latest Version
Avg Release Cycle
Latest Release

Changelog History
Page 1

  • v0.6.5

    🚀 This release contains many bug fixes all across the board. There is also 🆕 new optimization and many organisational improvements.

    🐛 Bug Fixes

    • 🛠 Python3.4+: Fixed issues with modules that exited with an exception, that could lead to a crash, dealing with their __spec__ value.

    • Python3.4+: The __loader__ method is_package had the wrong signature.

    • Python3.6+: Fix for async with being broken with uncompiled generators.

    • Python3.5+: Fix for coroutines that got their awaited object closed behind their back, they were complaining with RuntimeError should they be closed themselves.

    • 🛠 Fix, constant values None in a bool target that could not be optimized away, lead to failure during code generation.

    .. code-block:: python

    if x() and None:
    • 📦 Standalone: Added support for sha224, sha384, sha512 in crypto package.

    • 🏁 Windows: The icon wasn't properly attached with MinGW64 anymore, this was a regression.

    • 🏁 Windows: For compiler outputs, also attempt preferred locale to interpret outputs, so we have a better chance to not crash over MSVC error messages that are not UTF-8 compatible.

    • 🍎 macOS: Handle filename collisions for generated code too, Nuitka now treats all filesystems for all OS as case insensitive for this purpose.

    • 👻 Compatibility: Added support for tolerant del in class exception handlers.

    .. code-block:: python

    class C:
      except Exception as e:
        del e
        # At exception handler exit, "e" is deleted if still assigned

    We already were compatible for functions and modules here, but due to the special nature of class variables really living in dictionaries, this was delayed. But after some other changes, it was now possible to solve this TODO.

    • 👍 Standalone: Added support for Python3 variant of Pmw.

    • 🛠 Fix, the NumPy plugin now handles more installation types.

    • 🛠 Fix, the qt plugin now handles multiple library paths.

    • 🛠 Fix, need libm for some Anaconda variants too.

    • 🛠 Fix, left over bytecode from plugins could crash the plugin loader.

    • 🛠 Fix, pkgutil.iter_packages is now working for loaded packages.

    🆕 New Features

    • Python3.8: Followed some of the changes and works with beta2 as a Python 3.7, but none of the new features are implemented yet.

    • ➕ Added support for Torch, Tensorflow, Gevent, Sklearn, with a new Nuitka plugin.

    • ➕ Added support for "hinted" compilation, where the used modules are determined through a test run.

    • ➕ Added support for including TCL on Linux too.


    • ➕ Added support for the any built-in. This handles a wide range of type shapes and constant values at compile time, while also having optimized C code.

    • Generate code for some CLONG operations in preparation of eventual per expression C type selection, it then will allow to avoid objects in many instances.

    • 🏁 Windows: Avoid creating link libraries for MinGW64 as these have become unnecessary is the mean time.

    • 📦 Packages: Do not export entry points for all included packages, only for the main package name it is importable as.


    • ➕ Added support for Visual Studio 2019 as a C compiler backend.

    • 👌 Improved plugin documentation describing how to create plugins for Nuitka even better.

    • ✅ The is now a mode for running the tests called all which will execute all the tests and report their errors, and only fail at the very end. This doesn't avoid wasting CPU cycles to report that e.g. all tests are broken, but it allows to know all errors before fixing some.

    • ➕ Added repository for Fedora 30 for download.

    • Ask people to compile hello world program in the Github issue template, because many times, they have setup problems only.

    • Visual Studio Code is now the recommended IDE and has integrated configuration to make it immediately useful.

    • ⚡️ Updated internal copy of Scons to 3.1.0 as it incorporates many of our patches.

    • 🔄 Changed wordings for optimization to use "lowering" as the only term to describe an optimization that simplifies.


    • 🔌 Plugins: Major refactoring of Nuitka plugin API.

    • 🔌 Plugins: To locate module kind, use core Nuitka code that handles more cases.

    • 👕 The test suite runners are also now autoformatted and checked with PyLint.

    • 👕 The Scons file is now PyLint clean too.

    • 🏗 Avoid build_definitions.h to be included everywhere, in that it's only used in the main program part. This makes C linter hate us much less for using a non-existent file.

    ✅ Tests

    • 🍎 Run the tests using Travis on macOS too.

    • ✅ More standalone tests have been properly whitelisting to cover openSSL usage from local system.

    • ✅ Disabled PySide2 test, it's not useful to fail and ignore it.

    • ✅ Tests: Fixups for coverage testing mode.

    • ✅ Tests: Temporarily disable some checks for constants code in reflected tests as it only exposes marshal not being deterministic.


    🚀 This release is huge again. Main points are compatibility fixes, esp. on the coroutine side. These have become apparently very compatible now and 👍 we might eventually focus on making them better.

    Again, GSoC 2019 is also showing effects, and will definitely continue to 🚀 do soin the next release.

    Many use cases have been improved, and on an organizational level, the 👀 adoption of Visual Studio Code seems an huge improvement to have a well 🔧 configured IDE out of the box too.

    🚀 In upcoming releases, more built-ins will be optimized, and hopefully the specialization of operations will hit more and more code with more of the infrastructure getting there.

  • v0.6.4

    🚀 This release contains many bug fixes all across the board. There is also 🆕 new optimization and many organisational improvements.

    🐛 Bug Fixes

    • 📦 When linking very large programs or packages, with gcc compiler, Scons can produce commands that are too large for the OS. This happens sooner on the Windows OS, but also on Linux. We now have a workaround that avoids long command lines by using @sources.tmp syntax.

    • 🚚 Standalone: Remove temporary module after its use, instead of keeping it in sys.modules where e.g. Quart code tripped over its __file__ value that is illegal on Windows.

    • 🛠 Fixed non-usage of our enhanced detection of gcc version for compilers if given as a full path.

    • 🛠 Fixed non-detection of gnu-cc as a form of gcc compiler.

    • Python3.4: The __spec__ value corrections for compiled modules was not taking into account that there was a __spec__ value, which can happen if something is wrapping imported modules.

    • Standalone: Added implicit dependencies for passlib.

    • 🏁 Windows: Added workaround for OS command line length limit in compilation with MinGW64.

    • 🔌 Python2: Revive the enum plugin, there are backports of the buggy code it tries to patch up.

    • 🏁 Windows: Fixup handling of SxS with non zero language id, these occur e.g. in Anaconda.

    • 🔌 Plugins: Handle multiple PyQt plugin paths, e.g. on openSUSE this is done, also enhanced finding that path with Anaconda on Windows.

    • 🔌 Plugins: For multiprocessing on Windows, allow the .exe suffix to not be present, which can happen when ran from command line.

    • 🏁 Windows: Better version checks for DLLs on Python3, the ctypes helper code needs more definitions to work properly.

    • 👍 Standalone: Added support for both pycryptodome and pycryptodomex.

    • 🛠 Fix, the chr built-in was not giving fully compatible error on non number input.

    • 🛠 Fix, the id built-in doesn't raise an exception, but said otherwise.

    • Python3: Proper C identifiers for names that fit into latin-1, but are not ascii encodings.

    🆕 New Features

    • 🏁 Windows: Catch most common user error of using compiler from one architecture against Python from another. We now check those and compare it, and if they do not match, inform the user directly. Previously the compilation could fail, or the linking, with cryptic errors.

    • Distutils: Using setuptools and its runners works now too, not merely only pure distutils.

    • Distutils: Added more ways to pass Nuitka specific options via distutils.

    • ✅ Python3.8: Initial compatibility changes to get basic tests to work.


    • Nuitka is participating in the GSoC 2019 with 2 students, Batakrishna and Tommy.

    • Point people creating PRs to using the pre-commit hook in the template. Due to making the style issues automatic, we can hope to encounter less noise and resulting merge problems.

    • Many improvements to the pre-commit hook were done, hopefully completing its development.

    • ⚡️ Updated to latest pylint, black, and isort versions, also added codespell to check for typos in the source code, but that is not automated yet.

    • ➕ Added description of how to use experimental flags for your PRs.

    • ✂ Removed mirroring from Bitbucket and Gitlab, as we increasingly use the Github organisation features.

    • ➕ Added support for Ubuntu Disco, removed support for Ubuntu Artful packages.


    • 🏁 Windows: Attach data blobs as Windows resource files directly for programs and avoid using C data files for modules or MinGW64, which can be slow.

    • Specialization of helper codes for + is being done for more types and more thoroughly and fully automatic with Jinja2 templating code. This does replace previously manual code.

    • ➕ Added specialization of helper codes for * operation which is entirely new.

    • ➕ Added specialization of helper codes for - operation which is entirely new.

    • Dedicated nodes for specialized operations now allow to save memory and all use type shape based analysis to predict result types and exception control flow.

    • 👍 Better code generation for boolean type values, removing error checks when possible.

    • 👍 Better static analysis for even more type operations.


    • 🛠 Fixed many kinds of typos in the code base with codespell.

    • ✅ Apply automatic formatting to more test runner code, these were previously not done.

    • Avoid using shutil.copytree which fails to work when directory already exists, instead provide nuitka.util.FileOperations.copyTree and use that exclusively.

    ✅ Tests

    • ➕ Added new mode of operation to test runners, only that executes just one test and stops, useful during development.

    • ➕ Added new mechanism for standalone tests to expression modules that need to be importable, or else to skip the test by a special comment in the file, instead of by coded checks in the test runner.

    • ➕ Added also for more complex cases, another form of special comment, that can be any expression, that decides if the test makes sense.

    • ✅ Cover also setuptools in our distutils tests and made the execution more robust against variable behavior of distutils and setuptools.

    • ➕ Added standalone test for Urllib3.

    • ➕ Added standalone test for rsa.

    • ➕ Added standalone test for Pmw.

    • ➕ Added standalone test for passlib.


    🚀 Again this release is a sign of increasing adoption of Nuitka. The GSoC 🚀 2019 is also showing effects, definitely will in the next release.

    🚀 This release has a lot of new optimization, called specialization, but for it to really used, in many instances, we need to get away from working on C types for variables only, and get to them beig used for expressions more often. Otherwise much of the new special code is not used for most code.

    🚀 The focus of this release has been again to open up development further 🛠 and to incorporate findings from users. The number of fixes or new use cases working is astounding.

    🚀 In upcoming releases, new built-ins will be optimized, and specialization of operations will hit more and more code now that the infrastructure for it is in place.

  • v0.6.3

    This has a focus on organisational improvements. With more and more people joining Nuitka, normal developers as well as many GSoC 2019 students, the main focus was to open up the development 📚 tools and processes, and to improve documentation.

    🛠 That said, an impressive amount of bug fixes was contributed, but optimization was on hold.

    🐛 Bug Fixes

    • 🏁 Windows: Added support for running compiled binaries in unicode path names.

    • 📦 Standalone: Added support for crytodomex and pycparser packages.

    • 🏁 Standalone: Added support for OpenSSL support in PyQt on Windows.

    • 🏁 Standalone: Added support for OpenGL support with QML in PyQt on Windows.

    • 🔌 Standalone: Added support for SciPy and extended the NumPy plugin to also handle it.

    • 🔌 UI: The option --plugin-list still needed a positional argument to work.

    • 👉 Make sure sys.base_prefix is set correctly too.

    • Python3: Also make sure sys.exec_prefix and sys.base_exec_prefix are set correctly.

    • 0️⃣ Standalone: Added platform plugins for PyQt to the default list of sensible plugins to include.

    • 🛠 Fix detection of standard library paths that include .. path elements.


    • Avoid static C++ runtime library when using MinGW64.

    🆕 New Features

    • 🔌 Plugins: A plugin may now also generate data files on the fly for a given module.

    • ➕ Added support for FreeBSD/PowerPC arch which still uses gcc and not clang.


    • Nuitka is participating in the GSoC 2019.

    • ➕ Added documentation on how to create or use Nuitka plugins.

    • ➕ Added more API doc to functions that were missing them as part of the ongoing effort to complete it.

    • ⚡️ Updated to latest PyLint 2.3.1 for checking the code.

    • Scons: Using newer Scons inline copy with Python 2.7 as, the old one remains only used with Python 2.6, making it easier to know the relevant code.

    • Autoformat was very much enhanced and handles C and ReST files too now. For Python code it does pylint comment formatting, import statement sorting, and blackening.

    • ➕ Added script misc/ that adds a commit hook that runs autoformat on commit. Currently it commits unstaged content and therefore is not yet ready for prime time.

    • 🚚 Moved adapted CPython test suites to Github repository under Nuitka Organisation <>__.

    • 🚚 Moved Nuitka-website repository to Github repository under Nuitka Organisation <>__.

    • 🚚 Moved Nuitka-speedcenter repository to Github repository under Nuitka Organisation <>__.

    • There is now a Gitter chat for Nuitka community <>__.

    • 📚 Many typo and spelling corrections on all the documentation.

    • ➕ Added short installation guide for Nuitka on Windows.


    • 🚚 Moved commandline parsing helper functions from common code helpers to the main program where of course their only usage is.

    • 🚚 Moved post processing of the created standalone binary from main control to the freezer code.

    • 🚚 Avoid using chmod binary to remove executable bit from created extension modules.

    • 🏁 Windows: Avoid using rt.exe and mt.exe to deal with copying the manifest from the python.exe to created binaries. Instead use new code that extracts and adds Windows resources.

    • 🛠 Fixed many ResourceWarnings on Python3 by improved ways of handling files.

    • 🛠 Fixed deprecation warnings related to not using

    • The runners in bin directory are now formatted with black too.

    ✅ Tests

    • 🏁 Detect Windows permission errors for two step execution of Nuitka as well, leading to retries should they occur.

    • The salt value for CPython cached results was improved to take more things into account.

    • ✅ Tests: Added more trick assignments and generally added more tests that were so far missing.


    With the many organisational changes in place, my normal work is expected to resume for after and yield quicker improvements now.

    It is also important that people are now enabled to contribute 🌐 to the Nuitka web site and the Nuitka speedcenter. Hope is to 👀 see more improvements on this otherwise neglected areas.

    👀 And generally, it's great to see that a community of people is 🚀 now looking at this release in excitement and pride. Thanks to everybody who contributed!

  • v0.6.2

    🚀 This release has a huge focus on organizational things. Nuitka is growing in 👍 terms of contributors and supported platforms.

    🐛 Bug Fixes

    • 🛠 Fix, the Python flag --python-flag=-O was removing doc strings, but that should only be done with --python-flag=-OO which was added too.

    • 🛠 Fix, accelerated binaries failed to load packages from the virtualenv (not venv) that they were created and ran with, due to not propagating sys.prefix.

    • Standalone: Do not include plat-* directories as frozen code, and also on some platforms they can also contain code that fails to import without error.

    • Standalone: Added missing implicit dependency needed for newer NumPy versions.

    🆕 New Features

    • ➕ Added support for Alpine Linux.

    • ➕ Added support for MSYS2 based Python on Windows.

    • ➕ Added support for Python flag --python flag=-OO, which allows to remove doc strings.

    • ➕ Added experimental support for pefile based dependency scans on Windows, thanks to Orsiris for this contribution.

    • ➕ Added plugin for proper Tkinter standalone support on Windows, thanks to Jorj for this contribution.

    • There is now a __compiled__ attribute for each module that Nuitka has compiled. Should be like this now, and contains Nuitka version information for you to use, similar to what sys.version_info gives as a namedtuple for your checks.

    .. code-block:: python

    __nuitka_version__(major=0, minor=6, micro=2, releaselevel='release')


    • Experimental code for variant types for int and long values, that can be plain C value, as well as the PyObject *. This is not yet completed though.

    • Minor refinements of specialized code variants reducing them more often the actual needed code.


    • The Nuitka Github Organisation that was created a while ago and owns the Nuitka repo now, has gained members. Check out for their list. This is an exciting transformation for Nuitka.

    • Nuitka is participating in the GSoC 2019 under the PSF umbrella. We hope to grow even further. Thanks to the mentors who volunteered for this important task. Check out the GSoC 2019 page <>__ and thanks to the students that are already helping out.

    • ➕ Added Nuitka internal API documentation <>__ that will receive more love in the future. It got some for this release, but a lot is missing.

    • The Nuitka code has been black-ened and is formatted with an automatic tool now all the way, which makes contributors lives easier.

    • ➕ Added documentation for questions received as part of the GSoC applications and ideas work.

    • 📚 Some proof reading pull requests were merged for the documentation, thanks to everybody who addresses these kinds of errors. Sometimes typos, sometimes broken links, etc.

    • ⚡️ Updated inline copy of Scons used for Python3 to 3.0.4, which hopefully means more bugs are fixed.


    🚀 This release is a sign of increasing adoption of Nuitka. The GSoC 2019 is 👉 showing early effects, as is more developers joining the effort. These are great times for Nuitka.

    🚀 This release has not much on the optimization side that is user visible, but the work that has begun is capable of producing glorious benchmarks once it will be finished.

    🚀 The focus on this and coming releases is definitely to open up the Nuitka development now that people are coming in as permanent or temporary contributors in (relatively) high numbers.

  • v0.6.1

    🚀 This release comes after a relatively long time, and contains important new 🛠 optimization work, and even more bug fixes.

    🐛 Bug Fixes

    • 🛠 Fix, the options --[no]follow-import-to=package_name was supposed to not follow into the given package, but the check was executed too broadly, so that e.g. package_name2 was also affected. Fixed in already.

    • 🛠 Fix, wasn't detecting multiple recursions into the same package in module mode, when attempting to compile a whole sub-package. Fixed in already.

    • 🛠 Fix, constant values are used as C boolean values still for some of the cases. Fixed in already.

    • 🛠 Fix, referencing a function cannot raise an exception, but that was not annotated. Fixed in already.

    • 🍎 macOS: Use standard include of C bool type instead of rolling our own, which was not compatible with newest Clang. Fixed in already.

    • Python3: Fix, the bytes built-in type actually does have a __float__ slot. Fixed in already.

    • Python3.7: Types that are also sequences still need to call the method __class_getitem__ for consideration. Fixed in already.

    • 🏁 Python3.7: Error exits from program exit could get lost on Windows due to __spec__ handling not preserving errors. Fixed in already.

    • 🏁 Windows: Negative exit codes from Nuitka, e.g. due to a triggered assertion in debug mode were not working. Fixed in already.

    • 🛠 Fix, conditional and expressions were mis-optimized when not used to not execute the right hand side still. Fixed in already.

    • Python3.6: Fix, generators, coroutines, and asyncgen were not properly supporting annotations for local variables. Fixed in already.

    • ✅ Python3.7: Fix, class declarations had memory leaks that were untestable before 3.7.1 fixed reference count issues in CPython. Fixed in already.

    • Python3.7: Fix, asyncgen expressions can be created in normal functions without an immediate awaiting of the iterator. This new feature was not correctly supported.

    • 🛠 Fix, star imports on the module level should disable built-in name optimization except for the most critical ones, otherwise e.g. names like all or pow can become wrong. Previous workarounds for pow were not good enough.

    • 🛠 Fix, the scons for Python3 failed to properly report build errors due to a regression of the Scons version used for it. This would mask build errors on Windows.

    • 📦 Python3.4: Fix, packages didn't indicate that they are packages in their __spec__ value, causing issues with importlib_resources module.

    • Python3.4: The __spec__ values of compiled modules didn't have compatible origin and has_location values preventing importlib_resources module from working to load data files.

    • 🛠 Fix, packages created from .pth files were also considered when checking for sub-packages of a module.

    • 🏁 Standalone: Handle cases of conflicting DLLs better. On Windows pick the newest file version if different, and otherwise just report and pick randomly because we cannot really decide which ought to be loaded.

    • 🏁 Standalone: Warn about collisions of DLLs on non-Windows only as this can happen with wheels apparently.

    • 🏁 Standalone: For Windows Python extension modules .pyd files, remove the SxS configuration for cases where it causes problems, not needed.

    • 🛠 Fix: The exec statement on file handles was not using the proper filename when compiling, therefore breaking e.g. inspect.getsource on functions defined there.

    • 🔌 Standalone: Added support for OpenGL platform plugins to be included automatically.

    • Standalone: Added missing implicit dependency for zmq module.

    • Python3.7: Fix, using the -X utf8 flag on the calling interpreter, aka --python-flag=utf8_mode was not preserved in the compiled binary in all cases.

    🆕 New Optimization

    • Enabled C target type void which will catch creating unused stuff more immediately and give better code for expression only statements.

    • Enabled in-place optimization for module variables, avoiding write back to the module dict for unchanged values, accelerating these operations.

    • Compile time memory savings for the yield node of Python2, no need to track if it is in an exception handler, not relevant there.

    • Using the single child node for the yield nodes gives memory savings at compile time for these, while also making them operate faster.

    • ⚡️ More kinds of in-place operations are now optimized, e.g. int += int and the bytes ones were specialized to perform real in-place extension where possible.

    • Loop variables no longer loose type information, but instead collect the set of possible type shapes allowing optimization for them.


    • 📦 Corrected download link for Arch AUR link of develop package.

    • ➕ Added repository for Ubuntu Cosmic (18.10) for download.

    • ➕ Added repository for Fedora 29 for download.

    • Describe the exact format used for clang-format in the Developer Manual.

    • ➕ Added description how to use CondaCC on Windows to the User Manual.


    • The operations used for async for, async with, and await were all doing a look-up of an awaitable, and then executing the yield from that awaitable as one thing. Now this is split into two parts, with a new ExpressionYieldFromAwaitable as a dedicated node.

    • The yield node types, now 3 share a base class and common computation for now, enhancing the one for awaitiable, which was not fully annotating everything that can happen.

    • In code generation avoid statement blocks that are not needed, because there are no local C variables declared, and properly indent them.

    ✅ Tests

    • 🛠 Fixups for the manual Valgrind runner and the UI changes.

    • 🔒 Test runner detects lock issue of clcache on Windows and considers it a permission problem that causes a retry.


    This addresses even more corner cases not working correctly, the out of the 👍 box experience should be even better now.

    🐎 The push towards C level performance for integer operation was held up by the realization that loop SSA was not yet there really, and that it had to be implemented, which of course now makes a huge difference for the cases where e.g. bool are being used. There is no C type for int used yet, which 👍 limits the impact of optimization to only taking shortcuts for the supported 🏗 types. These are useful and faster of course, but only building blocks for what is to come.

    Most of the effort went into specialized helpers that e.g. add a float and and int value in a dedicated fashion, as well as comparison operations, so we can fully operate some minimal examples with specialized code. This is too limited still, and must be applied to ever more operations.

    What's more is that the benchmarking situation has not improved. Work will be needed in this domain to make improvements more demonstrable. It may well end 🚀 up being the focus for the next release to improve Nuitka speedcenter to give more fine grained insights across minor changes of Nuitka and graphs with more history.

  • v0.6.0

    🚀 This release adds massive improvements for optimization and a couple of 🐛 bug fixes.

    It also indicates reaching the mile stone of doing actual type inference, even if only very limited.

    💻 And with the new version numbers, lots of UI changes go along. The options to control recursion into modules have all been renamed, some now have 0️⃣ different defaults, and finally the filenames output have changed.

    🐛 Bug Fixes

    • 🚚 Python3.5: Fix, the awaiting flag was not removed for exceptions thrown into a coroutine, so next time it appeared to be awaiting instead of finished.

    • Python3: Classes in generators that were using built-in functions crashed the compilation with C errors.

    • 🛠 Some regressions for XML outputs from previous changes were fixed.

    • 🛠 Fix, hasattr was not raising an exception if used with non-string attributes.

    • For really large compilations, MSVC linker could choke on the input file, line length limits, which is now fixed for the inline copy of Scons.

    • Standalone: Follow changed hidden dependency of PyQt5 to PyQt5.sip for newer versions

    • Standalone: Include certificate file using by requests module in some cases as a data file.

    🆕 New Optimization

    • Enabled C target type nuitka_bool for variables that are stored with boolean shape only, and generate C code for those

    • Using C target type nuitka_bool many more expressions are now handled better in conditions.

    • ✨ Enhanced is and is not to be C source type aware, so they can be much faster for them.

    • 👉 Use C target type for bool built-in giving more efficient code for some source values.

    • Annotate the not result to have boolean type shape, allowing for more compile time optimization with it.

    • ⏪ Restored previously lost optimization of loop break handling StopIteration which makes loops much faster again.

    • ⏪ Restore lost optimization of subscripts with constant integer values making them faster again.

    • ⚡️ Optimize in-place operations for cases where left, right, or both sides have known type shapes for some values. Initially only a few variants were added, but there is more to come.

    • When adjacent parts of an f-string become known string constants, join them at compile time.

    • When there is only one remaining part in an f-string, use that directly as the result.

    • ⚡️ Optimize empty f-strings directly into empty strings constant during the tree building phase.

    • ➕ Added specialized attribute check for use in re-formulations that doesn't expose exceptions.

    • ✂ Remove locals sync operation in scopes without local variables, e.g. classes or modules, making exec and the like slightly leaner there.

    • ✂ Remove try nodes that did only re-raise exceptions.

    • The del of variables is now driven fully by C types and generates more compatible code.

    • ✂ Removed useless double exception exits annotated for expressions of conditions and added code that allows conditions to adapt themselves to the target shape bool during optimization.

    🆕 New Features

    • ➕ Added support for using .egg files in PYTHONPATH, one of the more rare uses, where Nuitka wasn't yet compatible.

    • 🏁 Output binaries in standalone mode with platform suffix, on non-Windows that means no suffix. In accelerated mode on non-Windows, use .bin as a suffix to avoid collision with files that have no suffix.

    • 🏁 Windows: It's now possible to use clang-cl.exe for CC with Nuitka as a third compiler on Windows, but it requires an existing MSVC install to be used for resource compilation and linking.

    • 🏁 Windows: Added support for using ccache.exe and clcache.exe, so that object files can now be cached for re-compilation.

    • For debug mode, report missing in-place helpers. These kinds of reports are to become more universal and are aimed at recognizing missed optimization chances in Nuitka. This features is still in its infancy. Subsequent releases will add more like these.


    • 🌐 Disabled comments on the web site, we are going to use Twitter instead, once the site is migrated to an updated Nikola.

    • The static C code is now formatted with clang-format to make it easier for contributors to understand.

    • 🚚 Moved the construct runner to top level binary and use it from there, with future changes coming that should make it generally useful outside of Nuitka.

    • ✨ Enhanced the issue template to tell people how to get the develop version of Nuitka to try it out.

    • ➕ Added documentation for how use the object caching on Windows to the User Manual.

    • ✂ Removed the included GUI, originally intended for debugging, but XML outputs are more powerful anyway, and it had been in disrepair for a long time.

    • ✂ Removed long deprecated options, e.g. --exe which has long been the default and is no more accepted.

    • 🔌 Renamed options to include plugin files to --include-plugin-directory and --include-plugin-files for more clarity.

    • 📇 Renamed options for recursion control to e.g. --follow-imports to better express what they actually do.

    • ✂ Removed --python-version support for switching the version during compilation. This has only worked for very specific circumstances and has been deprecated for a while.

    • ✂ Removed --code-gen-no-statement-lines support for not having line numbers updated at run time. This has long been hidden and probably would never gain all that much, while causing a lot of incompatibilty.


    • 🚚 Moved command line arguments to dedicated module, adding checks was becoming too difficult.

    • 🚚 Moved rich comparison helpers to a dedicated C file.

    • Dedicated binary and unary node bases for clearer distinction and more efficient memory usage of unuary nodes. Unary operations also no longer have in-place operation as an issue.

    • Major cleanup of variable accesses, split up into multiple phases and all including module variables being performed through C types, with no special cases anymore.

    • Partial cleanups of C type classes with code duplications, there is much more to resolve though.

    • 🏁 Windows: The way exec was performed is discouraged in the subprocess documentation, so use a variant that cannot block instead.

    • Code proving information about built-in names and values was using not very portable constructs, and is now written in a way that PyPy would also like.

    ✅ Tests

    • ✅ Avoid using 2to3 for basic operators test, removing test of some Python2 only stuff, that is covered elsewhere.

    • ➕ Added ability to cache output of CPython when comparing to it. This is to allow CI tests to not execute the same code over and over, just to get the same value to compare with. This is not enabled yet.


    🚀 This release marks a point, from which on performance improvements are likely 🚀 in every coming release. The C target types are a major milestone. More C target types are in the work, e.g. void is coming for expressions that are 🚀 done, but not used, that is scheduled for the next release.

    Although there will be a need to also adapt optimization to take full advantage of it, progress should be quick from here. There is a lot of ground to cover, with more C types to come, and all of them needing specialized helpers. But as soon as e.g. int, str are covered, many more programs are going to benefiting from this.

  • v0.5.33

    🚀 This release contains a bunch of fixes, most of which were previously released 🚑 as part of hotfixes, and important new optimization for generators.

    🐛 Bug Fixes

    • 🛠 Fix, nested functions with local classes using outside function closure variables were not registering their usage, which could lead to errors at C compile time. Fixed in already.

    • 🛠 Fix, usage of built-in calls in a class level could crash the compiler if a class variable was updated with its result. Fixed in already.

    • Python 3.7: The handling of non-type bases classes was not fully compatible and wrong usages were giving AttributeError instead of TypeError. Fixed in already.

    • 👻 Python 3.5: Fix, await expressions didn't annotate their exception exit. Fixed in already.

    • 🆕 Python3: The enum module usages with __new__ in derived classes were not working, due to our automatic staticmethod decoration. Turns out, that was only needed for Python2 and can be removed, making enum work all the way. Fixed in already.

    • Fix, recursion into __main__ was done and could lead to compiler crashes if the main module was named like that. This is not prevented. Fixed in already.

    • Python3: The name for list contraction's frames was wrong all along and not just changed for 3.7, so drop that version check on it. Fixed in already.

    • 🛠 Fix, the hashing of code objects has creating a key that could produce more overlaps for the hash than necessary. Using a C1 on line 29 and C on line 129, was considered the same. And that is what actually happened. Fixed in already.

    • 🍎 macOS: Various fixes for newer Xcode versions to work as well. Fixed in already.

    • Python3: Fix, the default __annotations__ was the empty dict and could be modified, leading to severe corruption potentially. Fixed in already.

    • 👻 Python3: When an exception is thrown into a generator that currently does a yield from is not to be normalized.

    • 👻 Python3: Some exception handling cases of yield from were leaking references to objects. Fixed in already.

    • 📦 Python3: Nested namespace packages were not working unless the directory continued to exist on disk. Fixed in already.

    • 🛠 Standalone: Do not include icuuc.dll which is a system DLL. Fixed in already.

    • 🛠 Standalone: Added hidden dependency of newer version of sip. Fixed in already.

    • Standalone: Do not copy file permissions of DLLs and extension modules as that makes deleting and modifying them only harder. Fixed in already.

    • 🏁 Windows: The multiprocessing plugin was not always properly patching the run time for all module loads, made it more robust. Fixed in already.

    • Standalone: Do not preserve permissions of copied DLLs, which can cause issues with read-only files on Windows when later trying to overwrite or remove files.

    • Python3.4: Make sure to disconnect finished generators from their frames to avoid potential data corruption. Fixed in already.

    • Python3.5: Make sure to disconnect finished coroutines from their frames to avoid potential data corruption. Fixed in already.

    • Python3.6: Make sure to disconnect finished asyncgen from their frames to avoid potential data corruption. Fixed in already.

    • Python3.5: Explicit frame closes of frames owned by coroutines could corrupt data. Fixed in already.

    • Python3.6: Explicit frame closes of frames owned by asyncgen could corrupt data. Fixed in already.

    • Python 3.4: Fix threaded imports by properly handling _initializing in compiled modules `spec attributes. Before it happen that another thread attempts to use an unfinished module. Fixed in already.

    • 🛠 Fix, the options --include-module and --include-package were present but not visible in the help output. Fixed in already.

    • 🏁 Windows: The multiprocessing plugin failed to properly pass compiled functions. Fixed in already.

    • Python3: Fix, optimization for in-place operations on mapping values are not allowed and had to be disabled. Fixed in already.

    • 🛠 Python 3.5: Fixed exception handling with coroutines and asyncgen throw to not corrupt exception objects.

    • Python 3.7: Added more checks to class creations that were missing for full compatibility.

    • Python3: Smarter hashing of unicode values avoids increased memory usage from cached converted forms in debug mode.


    • The issue tracker on Github is now the one that should be used with Nuitka, winning due to easier issue templating and integration with pull requests.

    • 👻 Document the threading model and exception model to use for MinGW64.

    • ✂ Removed the enum plug-in which is no longer useful after the improvements to the staticmethod handling for Python3.

    • ➕ Added Python 3.7 testing for Travis.

    • 📚 Make it clear in the documentation that pyenv is not supported.

    • The version output includes more information now, OS and architecture, so issue reports should contain that now.

    • 👍 On PyPI we didn't yet indicated Python 3.7 as supported, which it of course is.

    🆕 New Features

    • ➕ Added support for MiniConda Python.


    • Using goto based generators that return from execution and resume based on heap storage. This makes tests using generators twice as fast and they no longer use a full C stack of 2MB, but only 1K instead.

    • Conditional a if cond else b, a and b,a or b` expressions of which the result value is are now transformed into conditional statements allowing to apply further optimizations to the right and left side expressions as well.

    • 0️⃣ Replace unused function creations with side effects from their default values with just those, removing more unused code.

    • Put all statement related code and declarations for it in a dedicated C block, making things slightly more easy for the C compiler to re-use the stack space.

    • 🏁 Avoid linking against libpython in module mode on everything but Windows where it is really needed. No longer check for static Python, not needed anymore.

    • More compact function, generator, and asyncgen creation code for the normal cases, avoid qualname if identical to name for all of them.

    • ⚡️ Python2 class dictionaries are now indeed directly optimized, giving more compact code.

    • 👻 Module exception exits and thus its frames have become optional allowing to avoid some code for some special modules.

    • Uncompiled generator integration was backported to 3.4 as well, improving compatibility and speed there as well.


    • Frame object and their cache declarations are now handled by the way of allocated variable descriptions, avoid special handling for them.

    • The interface to "forget" a temporary variable has been replaced with a new method that skips a number for it. This is done to keep expression use the same indexes for all their child expressions, but this is more explicit.

    • Instead of passing around C variables names for temporary values, we now have full descriptions, with C type, code name, storage location, and the init value to use. This makes the information more immediately available where it is needed.

    • Variable declarations are now created when needed and stored in dedicated variable storage objects, which then in can generate the code as necessary.

    • Module code generation has been enhanced to be closer to the pattern used by functions, generators, etc.

    • There is now only one spot that creates variable declaration, instead of previous code duplications.

    • Code objects are now attached to functions, generators, coroutines, and asyncgen bodies, and not anymore to the creation of these objects. This allows for simpler code generation.

    • ✂ Removed fiber implementations, no more needed.

    ✅ Tests

    • ✅ Finally the asyncgen tests can be enabled in the CPython 3.6 test suite as the corrupting crash has been identified.

    • 🏁 Cover ever more cases of spurious permission problems on Windows.

    • ➕ Added the ability to specify specific modules a comparison test should recurse to, making some CPython tests follow into modules where actual test code lives.


    🚀 This release is huge in many ways.

    First, finishing "goto generators" clears an old scalability problem of Nuitka that needed to be addressed. No more do generators/coroutines/asyncgen consume too much memory, but instead they become as lightweight as they ought to be.

    Second, the use of variable declarations carying type information all through the code generation, is an important pre-condition for "C types" work to resume 🚀 and become possible, what will be 0.6.0 and the next release.

    🐎 Third, the improved generator performance will be removing a lot of cases, where Nuitka wasn't as fast, as its current state not using "C types" yet, should allow. It is now consistently faster than CPython for everything related to generators.

    Fourth, the fibers were a burden for the debugging and linking of Nuitka on 🗄 various platforms, as they provided deprecated interfaces or not. As they are now gone, Nuitka ought to definitely work on any platform where Python works.

    From here on, C types work can take it, and produce the results we are waiting 🚀 for in the next major release cycle that is about to start.

    🚀 Also the amount of fixes for this release has been incredibly high. Lots of 🛠 old bugs esp. for coroutines and asyncgen have been fixed, this is not only faster, but way more correct. Mainly due to the easier debugging and interface to the context code, bugs were far easier to avoid and/or find.

  • v0.5.32

    🚀 This release contains substantial new optimization, bug fixes, and already the 🛠 full support for Python 3.7. Among the fixes, the enhanced coroutine work for compatibility with uncompiled ones is most important.

    🐛 Bug Fixes

    • 🛠 Fix, was optimizing write backs of attribute in-place assignments falsely.

    • 🛠 Fix, generator stop future was not properly supported. It is now the default for Python 3.7 which showed some of the flaws.

    • Python3.5: The __qualname__ of coroutines and asyncgen was wrong.

    • Python3.5: Fix, for dictionary unpackings to calls, check the keys if they are string values, and raise an exception if not.

    • Python3.6: Fix, need to check assignment unpacking for too short sequences, we were giving IndexError instead of ValueError for these. Also the error messages need to consider if they should refer to "at least" in their wording.

    • 🛠 Fix, outline nodes were cloned more than necessary, which would corrupt the code generation if they later got removed, leading to a crash.

    • Python3.5: Compiled coroutines awaiting uncompiled coroutines was not working properly for finishing the uncompiled ones. Also the other way around was raising a RuntimeError when trying to pass an exception to them when they were already finished. This should resolve issues with asyncio module.

    • 🛠 Fix, side effects of a detected exception raise, when they had an exception detected inside of them, lead to an infinite loop in optimization. They are now optimized in-place, avoiding an extra step later on.

    🆕 New Features

    • 👌 Support for Python 3.7 with only some corner cases not supported yet.


    • 👻 Delay creation of StopIteration exception in generator code for as long as possible. This gives more compact code for generations, which now pass the return values via compiled generator attribute for Python 3.3 or higher.

    • Python3: More immediate re-formulation of classes with no bases. Avoids noise during optimization.

    • Python2: For class dictionaries that are only assigned from values without side effects, they are not converted to temporary variable usages, allowing the normal SSA based optimization to work on them. This leads to constant values for class dictionaries of simple classes.

    • Explicit cleanup of nodes, variables, and local scopes that become unused, has been added, allowing for breaking of cyclic dependencies that prevented memory release.

    ✅ Tests

    • ✅ Adapted 3.5 tests to work with 3.7 coroutine changes.

    • ➕ Added CPython 3.7 test suite.


    • ✂ Removed remaining code that was there for 3.2 support. All uses of version comparisons with 3.2 have been adapted. For us, Python3 now means 3.3, and we will not work with 3.2 at all. This removed a fair bit of complexity for some things, but not all that much.

    • 🚀 Have dedicated file for import released helpers, so they are easier to find if necessary. Also do not have code for importing a name in the header file anymore, not performance relevant.

    • ⚠ Disable Python warnings when running scons. These are particularly given when using a Python debug binary, which is happening when Nuitka is run with --python-debug option and the inline copy of Scons is used.

    • Have a factory function for all conditional statement nodes created. This solved a TODO and handles the creation of statement sequences for the branches as necessary.

    • Split class reformulation into two files, one for Python2 and one for Python3 variant. They share no code really, and are too confusing in a single file, for the huge code bodies.

    • Locals scopes now have a registry, where functions and classes register their locals type, and then it is created from that.

    • Have a dedicated helper function for single argument calls in static code that does not require an array of objects as an argument.


    • There are now requirements-devel.txt and requirements.txt files aimed at usage with scons and by users, but they are not used in installation.


    🚀 This releases has this important step to add conversion of locals dictionary usages to temporary variables. It is not yet done everywhere it is possible, and the resulting temporary variables are not yet propagated in the all the 🚀 cases, where it clearly is possible. Upcoming releases ought to achieve that most Python2 classes will become to use a direct dictionary creation.

    ➕ Adding support for Python 3.7 is of course also a huge step. And also this 🚀 happened fairly quickly and soon after its release. The generic classes it ➕ adds were the only real major new feature. It breaking the internals for 👻 exception handling was what was holding back initially, but past that, it was really easy.

    🚀 Expect more optimization to come in the next releases, aiming at both the ability to predict Python3 metaclasses __prepare__ results, and at more optimization applied to variables after they became temporary variables.

  • v0.5.31

    🚀 This release is massive in terms of fixes, but also adds a lot of refinement 👍 to code generation, and more importantly adds experimental support for 👍 Python 3.7, while enhancing support for Pyt5 in standalone mode by a lot.

    🐛 Bug Fixes

    • Standalone: Added missing dependencies for PyQt5.Qt module.

    • 🔌 Plugins: Added support for PyQt5.Qt module and its qml plugins.

    • 🔌 Plugins: The sensible plugin list for PyQt now includes that platforms plugins on Windows too, as they are kind of mandatory.

    • Python3: Fix, for uninstalled Python versions wheels that linked against the Python3 library as opposed to Python3X, it was not found.

    • Standalone: Prefer DLLs used by main program binary over ones used by wheels.

    • 📦 Standalone: For DLLs added by Nuitka plugins, add the package directory to the search path for dependencies where they might live.

    • 🛠 Fix, the vars built-in didn't annotate its exception exit.

    • Python3: Fix, the bytes and complex built-ins needs to be treated as a slot too.

    • 🛠 Fix, consider if del variable must be assigned, in which case no exception exit should be created. This prevented Tkinter compilation.

    • 👍 Python3.6: Added support for the following language construct:

    .. code-block:: python

    d = {"metaclass" : M}
    class C(**d):
    • 👍 Python3.5: Added support for cyclic imports. Now a from import with a name can really cause an import to happen, not just a module attribute lookup.

    • 🛠 Fix, hasattr was never raising exceptions.

    • 🛠 Fix, bytearray constant values were considered to be non-iterable.

    • Python3.6: Fix, now it is possible to del __annotations__ in a class and behave compatible. Previously in this case we were falling back to the module variable for annotations used after that which is wrong.

    • 🛠 Fix, some built-in type conversions are allowed to return derived types, but Nuitka assumed the exact type, this affected bytes, int, long, unicode.

    • Standalone: Fix, the _socket module was insisted on to be found, but can be compiled in.

    🆕 New Features

    • ➕ Added experimental support for Python 3.7, more work will be needed though for full support. Basic tests are working, but there are are at least more coroutine changes to follow.

    • ➕ Added support for building extension modules against statically linked Python. This aims at supporting manylinux containers, which are supposed to be used for creating widely usable binary wheels for Linux. Programs won't work with statically linked Python though.

    • ➕ Added options to allow ignoring the Windows cache for DLL dependencies or force an update.

    • 👍 Allow passing options from distutils to Nuitka compilation via setup options.

    • ➕ Added option to disable the DLL dependency cache on Windows as it may become wrong after installing new software.

    • ➕ Added experimental ability to provide extra options for Nuitka to setuptools.

    • 🚚 Python3: Remove frame preservation and restoration of exceptions. This is not needed, but leaked over from Python2 code.


    • Apply value tracing to local dict variables too, enhancing the optimization for class bodies and function with exec statements by a lot.

    • 👍 Better optimization for "must not have value", wasn't considering merge traces of uninitialized values, for which this is also the case.

    • 👉 Use 10% less memory at compile time due to specialized base classes for statements with a single child only allowing __slots__ usage by not having multiple inheritance for those.

    • ⚡️ More immediately optimize branches with known truth values, so that merges are avoided and do not prevent trace based optimization before the pass after the next one. In some cases, optimization based on traces could fail to be done if there was no next pass caused by other things.

    • Much faster handling for functions with a lot of eval and exec calls.

    • Static optimization of type with known type shapes, the value is predicted at compile time.

    • ⚡️ Optimize containers for all compile time constants into constant nodes. This also enables further compile time checks using them, e.g. with isinstance or in checks.

    • Standalone: Using threads when determining DLL dependencies. This will speed up the un-cached case on Windows by a fair bit.

    • 🚚 Also remove unused assignments for mutable constant values.

    • ⚡️ Python3: Also optimize calls to bytes built-in, this was so far not done.

    • ⚡️ Statically optimize iteration over constant values that are not iterable into errors.

    • ✂ Removed Fortran, Java, LaTex, PDF, etc. stuff from the inline copies of Scons for faster startup and leaner code. Also updated to 3.0.1 which is no important difference over 3.0.0 for Nuitka however.

    • 🚀 Make sure to always release temporary objects before checking for error exits. When done the other way around, more C code than necessary will be created, releasing them in both normal case and error case after the check.

    • 🚚 Also remove unused assignments in case the value is a mutable constant.


    • Don't store "version" numbers of variable traces for code generation, instead directly use the references to the value traces instead, avoiding later lookups.

    • ➕ Added dedicated module for complex built-in nodes.

    • 🚚 Moved C helpers for integer and complex types to dedicated files, solving the TODOs around them.

    • ✂ Removed some Python 3.2 only codes.


    • 👍 For better bug reports, the --version output now contains also the Python version information and the binary path being used.

    • Started using specialized exceptions for some types of errors, which will output the involved data for better debugging without having to reproduce anything. This does e.g. output XML dumps of problematic nodes.

    • When encountering a problem (compiler crash) in optimization, output the source code line that is causing the issue.

    • ➕ Added support for Fedora 28 RPM builds.

    • ✂ Remove more instances of mentions of 3.2 as supported or usable.

    • Renovated the graphing code and made it more useful.


    🚀 This release marks important progress, as the locals dictionary tracing is a huge step ahead in terms of correctness and proper optimization. The actual ⚡️ resulting dictionary is not yet optimized, but that ought to follow soon now.

    👍 The initial support of 3.7 is important. Right now it apparently works pretty well as a 3.6 replacement already, but definitely a lot more work will be needed to fully catch up.

    🔌 For standalone, this accumulated a lot of improvements related to the plugin 🏁 side of Nuitka. Thanks to those involved in making this better. On Windows things ought to be much faster now, due to parallel usage of dependency walker.

  • v0.5.30

    🚀 This release has improvements in all areas. Many bug fixes are accompanied with optimization changes towards value tracing.

    🐛 Bug Fixes

    • 🛠 Fix, the new setuptools runners were not used by pip breaking the use of Nuitka from PyPI.

    • 🛠 Fix, imports of six.moves could crash the compiler for built-in names. Fixed in already.

    • 🏁 Windows: Make the nuitka-run not a symlink as these work really bad on that platform, instead make it a full copy just like we did for nuitka3-run already. Fixed in already.

    • Python3.5: In module mode, types.coroutine was monkey patched into an endless recursion if including more than one module, e.g. for a package. Fixed in already.

    • Python3.5: Dictionary unpackings with both star arguments and non star arguments could leak memory. Fixed in already.

    .. code-block:: python

    c = {a : 1, **d}
    • 🛠 Fix, distutils usage was not working for Python2 anymore, due to using super for what are old style classes on that version.

    • 🛠 Fix, some method calls to C function members could leak references.

    .. code-block:: python

    class C:
       for_call = functools.partial
       def m():
          self.for_call() # This leaked a reference to the descriptor.
    • Python3.5: The bases classes should be treated as an unpacking too.

    .. code-block:: python

    class C(*D): # Allowed syntax that was not supported.
    • 🏁 Windows: Added back batch files to run Nuitka from the command line. Fixed in already.

    🆕 New Features

    • ➕ Added option --include-package to force inclusion of a whole package with the submodules in a compilation result.

    • ➕ Added options --include-module to force inclusion of a single module in a compilation result.

    • The `multiprocessing plug-in got adapted to Python 3.4 changes and will now also work in accelerated mode on Windows.

    • 🔌 It is now possible to specify the Qt plugin directories with e.g. --enable-plugin=qt_plugins=imageformats and have only those included. This should avoid dependency creep for shared libraries.

    • 🔌 Plugins can now make the decision about recursing to a module or not.

    • 🔌 Plugins now can get their own options passed.


    • The re-raising of exceptions has gotten its own special node type. This aims at more readability (XML output) and avoiding the overhead of checking potential attributes during optimization.

    • 🔄 Changed built-in int, long, and float to using a slot mechanism that also analyses the type shape and detects and warns about errors at compile time.

    • 🔄 Changed the variable tracing to value tracing. This meant to cleanup all the places that were using it to find the variable.

    • Enable must have / must not value value optimization for all kinds of variables including module and closure variables. This often avoids error exits and leads to smaller and faster generated code.

    ✅ Tests

    • ➕ Added burn test with local install of pip distribution to virtualenv before making any PyPI upload. It seems pip got its specific error sources too.

    • Avoid calling 2to3 and prefer <python> -m lib2to3 instead, as it seems at least Debian Testing stopped to provide the binary by default. For Python 2.6 and 3.2 we continue to rely on it, as the don't support that mode of operation.

    • 👕 The PyLint checks have been made more robust and even more Python3 portable.

    • ➕ Added PyLint to Travis builds, so PRs are automatically checked too.

    • ➕ Added test for distutils usage with Nuitka that should prevent regressions for this new feature and to document how it can be used.

    • 🏁 Make coverage taking work on Windows and provide the full information needed, the rendering stage is not there working yet though.

    • ✅ Expanded the trick assignment test cases to cover more slots to find bugs introduced with more aggressive optimization of closure variables.

    • 🆕 New test to cover multiprocessing usage.

    • ✅ Generating more code tests out of doctests for increased coverage of Nuitka.


    • ✅ Stop using --python-version in tests where they still remained.

    • Split the forms of int and long into two different nodes, they share nothing except the name. Create the constants for the zero arg variant more immediately.

    • ✅ Split the output comparison part into a dedicated testing module so it can be re-used, e.g. when doing distutils tests.

    • ✂ Removed dead code from variable closure taking.

    • Have a dedicated module for the metaclass of nodes in the tree, so it is easier to find, and doesn't clutter the node base classes module as much.

    • Have a dedicated node for reraise statements instead of checking for all the arguments to be non-present.


    • There is now a pull request template for Github when used.

    • 🗄 Deprecating the --python-version argument which should be replaced by using -m nuitka with the correct Python version. Outputs have been updated to recommend this one instead.

    • 👉 Make automatic import sorting and autoformat tools properly executable on Windows without them changing new lines.

    • 📚 The documentation was updated to prefer the call method with -m nuitka and manually providing the Python binary to use.


    🚀 This release continued the distutils integration adding first tests, but more 🔋 features and documentation will be needed.

    Also, for the locals dictionary work, the variable tracing was made generic, but not yet put to use. If we use this to also trace dictionary keys, we can expect a lot of improvements for class code again.

    The locals dictionary tracing will be the focus before resuming the work on 🐎 C types, where the ultimate performance boost lies. However, currently, not the full compatibility has been achieved even with currently using dictionaries ⚡️ for classes, and we would like to be able to statically optimize those better anyway.