Use realpath() to get the absolute path of the executable; this resolves
symbolic links and ensures that changing the path before all imports are
complete does not result in the executable being unable to find modules.

Switched from using C compiled frozen modules which embed part of the
standard library to using the default named zip file and library file
locations. This eliminates the need to recompile cx_Freeze for each new
Python version as no parts of the standard library are included in the
installation now. This also implies that appending a zip file to the
executable is no longer supported since the standard name and location are
used.

Set defaults in class directly, rather than as defaults in the function
signature. (Issue #185)

Correct relative import of builtin module (cx_Freeze was incorrectly
considering it an extension found within a package). (Issue #127)

Ensure that included files are added relative to the executable, not to the
location of the zip file. (Issue #183)

Prevent infinite loop while using cx_Freeze installed in a prefix.
(Issue #204)

Added support for storing packages in the file system instead of in the zip
file. There are a number of packages that assume that they are found in the
file system and if found in a zip file instead produce strange errors. The
default is now to store packages in the file system but a method is
available to place packages in the zip file if they are known to behave
properly when placed there. (Issue #73)

Added support for untranslatable characters on Windows in the path where a
frozen executable is located. (Issue #29)

Added support for namespace packages which are loaded implicitly upon
startup by injection into sys.modules.

Added support for a Zope sample which makes use of namespace packages.

Use the Microsoft compiler on Windows for Python 2.6 and up as some
strange behaviors were identified with Python 2.7 when compiled using
mingw32.

Eliminate warning about -mwindows when using the Microsoft compiler for
building the Win32GUI base executable.

Added support for creating version resources on Windows.

Ensure that modules that are not truly required for bootstrapping are not
included in the frozen modules compiled in to the executable; otherwise,
some packages and modules (such as the logging package) cannot be found at
runtime. This problem only seems to be present in Python 2.7.1 but it is a
good improvement for earlier releases of Python as well.

Added support for setting the description for Windows services.

Added hook for using the widget plugins which are part of the PyQt4.uic
package.

Fixed support for installing frozen executables under Python 3.x on
Windows.

Removed optional import of setuptools which is not a complete drop-in
replacement for distutils and if found, replaces distutils with itself,
resulting in some distutils features not being available; for those who
require or prefer the use of setuptools, import it in your setup.py.

Improved packaging of MSI files by enabling support for creating shortcuts
for the executables, for specifying the initial target directory and for
adding other arbitrary configuration to the MSI.

Added support for namespace packages such as those distributed for zope.

The name of the generated MSI packages now includes the architecture in
order to differentiate between 32-bit and 64-bit builds.

Removed use of LINKFORSHARED on the Mac which is not necessary and for
Python 2.6 at least causes an error to be raised.

Turn off filename globbing on Windows as requested by Craig McQueen.

Fixed bug that prevented hooks from successfully including files in the
build (as is done for the matplotlib sample).

Fixed bug that prevented submodules from being included in the build if the
format of the import statement was from . import <name>.

Reverted bug fix for threading shutdown support which has been fixed
differently and is no longer required in Python 2.6.5 and up (in fact an
error is raised if the threading module is used in a frozen executable and
this code is retained).

Fixed bug which resulted in attempts to compile .pyc and .pyo files from
the initscripts directory.

Fixed selection of “Program Files” directory on Windows in 64-bit MSI
packages built by cx_Freeze.

Added support for binary path includes as well as excludes; use sequences
rather than dictionaries as a more convenient API; exclude the standard
locations for 32-bit and 64-bit libaries in multi-architecture systems.

Added support for searching zip files (egg files) for modules.

Added support for handling system exit exceptions similarly to what Python
does itself as requested by Sylvain.

Added code to wait for threads to shut down like the normal Python
interpreter does. Thanks to Mariano Disanzo for discovering this
discrepancy.

Hooks added or modified based on feedback from many people.

Don’t include the version name in the display name of the MSI.

Use the OS dependent path normalization routines rather than simply use the
lowercase value as on Unix case is important; thanks to Artie Eoff for
pointing this out.

Include a version attribute in the cx_Freeze package and display it in the
output for the –version option to the script.

Include build instructions as requested by Norbert Sebok.

Add support for copying files when modules are included which require data
files to operate properly; add support for copying the necessary files for
the Tkinter and matplotlib modules.

Handle deferred imports recursively as needed; ensure that from lists do
not automatically indicate that they are part of the module or the deferred
import processing doesn’t actually work!

Handle the situation where a module imports everything from a package and
the __all__ variable has been defined but the package has not actually
imported everything in the __all__ variable during initialization.

Modified license text to more closely match the Python Software Foundation
license as was intended.

Added sample script for freezing an application using matplotlib.

Renamed freeze to cxfreeze to avoid conflict with another package that uses
that executable as requested by Siegfried Gevatter.

In Common.c, used MAXPATHLEN defined in the Python OS independent include
file rather than the PATH_MAX define which is OS dependent and is not
available on IRIX as noted by Andrew Jones.

In the initscript ConsoleSetLibPath.py, added lines from initscript
Console.py that should have been there since the only difference between
that script and this one is the automatic re-execution of the executable.

Added an explicit “import encodings” to the initscripts in order to handle
Unicode encodings a little better. Thanks to Ralf Schmitt for pointing out
the problem and its solution.

Generated a meaningful name for the extension loader script so that it is
clear which particular extension module is being loaded when an exception
is being raised.

In MakeFrozenBases.py, use distutils to figure out a few more
platform-dependent linker flags as suggested by Ralf Schmitt.

Added option –default-path which is used to specify the path used when
finding modules. This is particularly useful when performing cross
compilations (such as for building a frozen executable for Windows CE).

Added option –shared-lib-name which can be used to specify the name of
the shared library (DLL) implementing the Python runtime that is required
for the frozen executable to work. This option is also particularly useful
when cross compiling since the normal method for determining this
information cannot be used.

Added option –zip-include which allows for additional files to be added
to the zip file that contains the modules that implement the Python
script. Thanks to Barray Warsaw for providing the initial patch.

Added support for handling read-only files properly. Thanks to Peter
Grayson for pointing out the problem and providing a solution.

Added support for a frozen executable to be a symbolic link. Thanks to
Robert Kiendl for providing the initial patch.

Enhanced the support for running a frozen executable that uses an existing
Python installation to locate modules it requires. This is primarily of
use for embedding Python where the interface is C but the ability to run
from source is still desired.

Modified the documentation to indicate that building from source on
Windows currently requires the mingw compiler (http://www.mingw.org).

Workaround the problem in Python 2.3 (fixed in Python 2.4) which causes a
broken module to be left in sys.modules if an ImportError takes place
during the execution of the code in that module. Thanks to Roger Binns
for pointing this out.

cx_Freeze now requires Python 2.3 or higher since it takes advantage of
the ability of Python 2.3 and higher to import modules from zip files.
This makes the freezing process considerably simpler and also allows for
the execution of multiple frozen packages (such as found in COM servers or
shared libraries) without requiring modification to the Python modules.

All external dependencies have been removed. cx_Freeze now only requires
a standard Python distribution to do its work.

Added the ability to define the initialization scripts that cx_Freeze uses
on startup of the frozen program. Previously, these scripts were written
in C and could not easily be changed; now they are written in Python and
can be found in the initscripts directory (and chosen with the
new –init-script option to FreezePython).

The base executable ConsoleSetLibPath has been removed and replaced with
the initscript ConsoleSetLibPath.

Removed base executables for Win32 services and Win32 COM servers. This
functionality will be restored in the future but it is not currently in a
state that is ready for release. If this functionality is required, please
use py2exe or contact me for my work in progress.

The attribute sys.frozen is now set so that more recent pywin32 modules
work as expected when frozen.

Added option –include-path to FreezePython to allow overriding of
sys.path without modifying the environment variable PYTHONPATH.

Added option –target-dir/–install-dir to specify the directory in which
the frozen executable and its dependencies will be placed.

Removed the option –shared-lib since it was used for building shared
libraries and can be managed with the initscript SharedLib.py.

MakeFrozenBases.py now checks the platform specific include directory as
requested by Michael Partridge.

Add option (–ext-list-file) to FreezePython to write the list of
extensions copied to the installation directory to a file. This option is
useful in cases where multiple builds are performed into the same
installation directory.

Pass the arguments on the command line through to Win32 GUI applications.
Thanks to Michael Porter for pointing this out.

Link directly against the python DLL when building the frozen bases on
Windows, thus eliminating the need for building an import library.

Force sys.path to include the directory in which the script to be frozen
is found.

Make sure that the installation directory exists before attempting to
copy the target binary into it.

The Win32GUI base has been modified to display fatal errors in message
boxes, rather than printing errors to stderr, since on Windows the
standard file IO handles are all closed.

Remove dependency on Python 2.2. Thanks to Paul Moore for not only
pointing it out but providing patches.

Set up the list of frozen modules in advance, rather than doing it after
Python is initialized so that implicit imports done by Python can be
satisfied. The bug in Python 2.3 that demonstrated this issue has been
fixed in the first release candidate. Thanks to Thomas Heller for pointing
out the obvious in this instance!

Added additional base executable (ConsoleSetLibPath) to support setting
the LD_LIBRARY_PATH variable on Unix platforms and restarting the
executable to put the new setting into effect. This is primarily of use
in distributing wxPython applications on Unix where the shared library
has an embedded RPATH value which can cause problems.

Small improvements of documentation based on feedback from several people.

Print information about the files written or copied during the freezing
process.

Do not copy extensions when freezing if the path is being overridden since
it is expected that a full Python installation is available to the target
users of the frozen binary.

Provide meaningful error message when the wxPython library cannot be
found during the freezing process.

Fixed import error with C extensions in packages; thanks to Thomas Heller
for pointing out the solution to this problem.

Added options to FreezePython to allow for the inclusion of modules which
will not be found by the module finder (–include-modules) and the
exclusion of modules which will be found by the module finder but should
not be included (–exclude-modules).