Compile on Windows/de

This article explains step by step how to compile FreeCAD on Windows.

See also
 * Compile on Windows with Visual Studio 2013
 * Compiling - Speeding up

Required programs

 * Git There are a number of alternatives such as GitCola, Tortoise Git, and others.
 * CMake version 2.x.x or Cmake 3.x.x
 * Python >2.5 (This is only required if NOT using the Libpack. The Libpack comes with a minimal Python(2.7.x) suitable for compiling and running FreeCAD)

Using Git (Preferred)
To create a local tracking branch and download the source code you need to open a terminal(command prompt) and cd to the directory you want the source, then type:

Compiler
On Windows, the default compiler is M$ Visual Studio, be it the Express or Full 2008, 2012, or 2013 versions. You will also need to install the Windows Platform SDK to get several required libraries (e.g. Windows.h), though they may not be required with M$ compilers (either full or express).

For those who want to avoid installing the huge Visual Studio for the mere purpose of having a compiler, see CompileOnWindows - Reducing Disk Footprint.

Third Party Libraries
You will need all of the Third Party Libraries to successfully compile FreeCAD. If you use the M$ compilers it is recommended to install a FreeCAD LibPack, which provides all of the required libraries to build FreeCAD in Windows. You will need the Libpack for your architecture and compiler. FreeCAD currently supplies Libpack Version11 for x32 and x64, for VS9 2008, VS11 2012, and VS12 2013.

Optional programs

 * NSIS Windows installer (note: formerly, WiX installer was used - now under transition to NSIS) - if you want to make msi installer

System Path Configuration
Inside your system path be sure to set the correct paths to the following programs:
 * git (not tortoiseGit, but git.exe) This is necessary for Cmake to properly update the "About FreeCAD" information in the version.h file which allows FreeCAD to report the proper version in About FreeCAD from the help menu.
 * Optionally you can include the Libpack in your system path. This is useful if you plan to build multiple configurations/versions of FreeCAD, you will need to copy less files as explained later in the build process.

To add to your system path:


 * Start menu -> Right click on Computer -> Properties -> Advanced system settings
 * Advanced tab -> Environment Variables...
 * Add the PATH/TO/GIT to the PATH
 * It should be separated from the others with a semicolon `;`

The switch to CMake
Currently, FreeCAD uses the CMake build system to generate build and make files that can be used between different operating systems and compilers. If you want build former versions of FreeCAD (0.8 and older) see Building older versions later in this article.

We switched because it became more and more painful to maintain project files for 30+ build targets and x compilers. CMake gives us the possibility to support alternative IDEs, like Code::Blocks, Qt Creator and Eclipse CDT. The main compiler is still M$ VC9 Express, though. But we plan for the future a build process on Windows without proprietary compiler software.

CMake
The first step to build FreeCAD with CMake is to configure the environment. There are two ways to do it:
 * Using the LibPack
 * Installing all the needed libraries and let CMake find them

The following process will assume you are using the LipPack. The second option may be discussed in Options for the Build Process.

Configure CMake using GUI

 * Open the CMake GUI
 * Specify the source folder
 * Specify the build folder
 * Click Configure
 * Specify the generator according to the IDE that you'll use.

This will begin configuration and should fail because the location of FREECAD_LIBPACK_DIR is unset.
 * Expand the FREECAD category and set FREECAD_LIBPACK_DIR to the correct location
 * Check FREECAD_USE_EXTERNAL_PIVY
 * Optionally Check FREECAD_USE_FREETYPE this is required to use the Draft WB's Shape String functionality
 * Click Configure again
 * There should be no errors
 * Click Generate
 * Close CMake
 * Copy libpack\bin folder into the new build folder CMake created

Options for the Build Process
The CMake build system gives us a lot more flexibility over the build process. That means we can switch on and off some features or modules. It's in a way like the Linux kernel build. You have a lot of switches to determine the build process.

Here is the description of some of these switches. They will most likely change a lot in the future because we want to increase the build flexibility a lot more.

If you are building with Qt Creator, jump to Building with Qt Creator, otherwise proceed to Building with Visual Studio 9 2008.

Building FreeCAD
Depending on your current setup, the process for building FreeCAD will be slightly different. This is due to the differences in available software and software versions for each operating system.

The following procedure will work for compiling on Windows Vista/7/8, for XP an alternate VS tool set is required for VS 2012 and 2013, which has not been tested successfully with the current Libpacks. To target XP(both x32 and x64) it is recommended to use VS2008 and Libpack FreeCADLibs_11.0_x86_VC9.7z

Building with Visual Studio 12 2013
Make sure to specify Visual Studio 12 x64(or the alternate C-Compiler you are using) as the generator in CMake before you continue.


 * Start Visual Studio 12 2013 by clicking on the desktop icon created at installation.

File -> Open -> Project/Solution
 * Open the project by:


 * Open FreeCAD_Trunk.sln from the build folder CMake created

This may take a while depending on your sytem
 * Switch the Solutions Configuration drop down at the top to Release X64


 * Build -> Build Solution


 * This will take a long time...

If you don't get any errors you are done. Exit Visual Studio and start FreeCAD by double clicking the FreeCAD icon in the bin folder of the build directory.

Building with Visual Studio 9 2008
Make sure to specify Visual Studio 9 2008 as the generator in CMake before you continue.
 * Open Visual Studio 9 2008 or Visual C++ Express 2008
 * File -> Open -> Project/Solution
 * Open FreeCAD_Trunk.sln from the build folder CMake created
 * Switch the Solutions Configuration dropdown at the top to Release
 * Build -> Build Solution to build
 * Wait until the Build is finished (will take a while)

After Building

 * Debug -> Start without Debugging
 * Click popup menu under Executable File Name and choose Browse
 * Go to the build\bin folder and choose FreeCAD.exe
 * You are done!

Installation and configuration of Qt Creator

 * Download and install Qt Creator
 * Tools -> Options -> Text Editor -> Behavior tab:
 * File Encodings -> Default Encodings:
 * Set to: ISO-8859-1 /...csISOLatin1 (Certain characters create errors/warnings with Qt Creator if left set to UTF-8. This seems to fix it.)
 * Tools -> Options -> Build & Run:
 * CMake tab
 * Fill Executable box with path to cmake.exe
 * Kits tab
 * Name: MSVC 2008
 * Compiler: Microsoft Visual C++ Compiler 9.0 (x86)
 * Debugger: Auto detected...
 * Qt version: None
 * General tab
 * Uncheck: Always build project before deploying it
 * Uncheck: Always deploy project before running it

Import project and Build

 * File -> Open File or Project
 * Open CMakeLists.txt which is in the top level of the source
 * This will start CMake
 * Choose build directory and click next
 * Set generator to NMake Generator (MSVC 2008)
 * Click Run CMake. Follow the instructions depicted above to configure CMake to your liking.

Now FreeCAD can be built
 * Build -> Build All
 * This will take a long time...

Once complete, it can be run: There are 2 green triangles at the bottom left. One is debug. The other is run. Pick whichever you want.

Command line build
Here an example how to build FreeCAD from the Command line:

Using LibPack
To make it easier to get FreeCAD compiled, we provide a collection of all needed libraries. It's called the LibPack. You can find it on the download page on sourceforge.

You need to set the following environment variables:


 * FREECADLIB = "D:\Wherever\LIBPACK"


 * QTDIR = "%FREECADLIB%"

Add "%FREECADLIB%\bin" and "%FREECADLIB%\dll" to the system PATH variable. Keep in mind that you have to replace "%FREECADLIB%" with the path name, since Windows does not recursively replace environment variables.

Directory setup in Visual Studio
Some search path of Visual Studio need to be set. To change them, use the menu ''Tools→Options→Directory

Includes
Add the following search path to the include path search list:
 * %FREECADLIB%\include
 * %FREECADLIB%\include\Python
 * %FREECADLIB%\include\boost
 * %FREECADLIB%\include\xercesc
 * %FREECADLIB%\include\OpenCascade
 * %FREECADLIB%\include\OpenCV
 * %FREECADLIB%\include\Coin
 * %FREECADLIB%\include\SoQt
 * %FREECADLIB%\include\QT
 * %FREECADLIB%\include\QT\Qt3Support
 * %FREECADLIB%\include\QT\QtCore
 * %FREECADLIB%\include\QT\QtGui
 * %FREECADLIB%\include\QT\QtNetwork
 * %FREECADLIB%\include\QT\QtOpenGL
 * %FREECADLIB%\include\QT\QtSvg
 * %FREECADLIB%\include\QT\QtUiTools
 * %FREECADLIB%\include\QT\QtXml
 * %FREECADLIB%\include\Gts
 * %FREECADLIB%\include\zlib

Libs
Add the following search path to the lib path search list:
 * %FREECADLIB%\lib

Executables
Add the following search path to the executable path search list:
 * %FREECADLIB%\bin
 * TortoiseSVN binary installation directory, usually "C:\Programm Files\TortoiseSVN\bin", this is needed for a distribution build when SubWVRev.exe is used to extract the version number from Subversion.

Python needed
During the compilation some Python scripts get executed. So the Python interpreter has to function on the OS. Use a command box to check it. If the Python library is not properly installed you will get an error message like Cannot find python.exe. If you use the LibPack you can also use the python.exe in the bin directory.

Special for VC8
When building the project with VC8, you have to change the link information for the WildMagic library, since you need a different version for VC6 and VC8. Both versions are supplied in LIBPACK/dll. In the project properties for AppMesh change the library name for the wm.dll to the VC8 version. Take care to change it in Debug and Release configuration.

Compile
After you conform to all prerequisites the compilation is - hopefully - only a mouse click in VC

After Compiling
To get FreeCAD up and running from the compiler environment you need to copy a few files from the LibPack to the bin folder where FreeCAD.exe is installed after a successful build:


 * python.exe and python_d.exe from LIBPACK/bin
 * python25.dll and python25_d.dll from LIBPACK/bin
 * python25.zip from LIBPACK/bin
 * make a copy of Python25.zip and rename it to Python25_d.zip
 * QtCore4.dll from LIBPACK/bin
 * QtGui4.dll from LIBPACK/bin
 * boost_signals-vc80-mt-1_34_1.dll from LIBPACK/bin
 * boost_program_options-vc80-mt-1_34_1.dll from LIBPACK/bin
 * xerces-c_2_8.dll from LIBPACK/bin
 * zlib1.dll from LIBPACK/bin
 * coin2.dll from LIBPACK/bin
 * soqt1.dll from LIBPACK/bin
 * QtOpenGL4.dll from LIBPACK/bin
 * QtNetwork4.dll from LIBPACK/bin
 * QtSvg4.dll from LIBPACK/bin
 * QtXml4.dll from LIBPACK/bin

When using a LibPack with a Python version older than 2.5 you have to copy two further files:
 * zlib.pyd and zlib_d.pyd from LIBPACK/bin/lib. This is needed by python to open the zipped python library.
 * _sre.pyd and _sre_d.pyd from LIBPACK/bin/lib. This is needed by python for the built in help system.

If you don't get it running due to a Python error it is very likely that one of the zlib*.pyd files is missing.

Alternatively, you can copy the whole bin folder of libpack into bin folder of the build. This is easier, but takes time and disk space. This can be substited by making links instead of copying files, see CompileOnWindows - Reducing Disk Footprint.

Additional stuff
If you whant to build the source code documentation you need DoxyGen.

To create an intstaller package you need WIX.

During the compilation some Python scripts get executed. So the Python interpreter has to work properly.

For more details have also a look to README.Linux in your sources.

First of all you should build the Qt plugin that provides all custom widgets of FreeCAD we need for the Qt Designer. The sources are located under //src/Tools/plugins/widget//. So far we don't provide a makefile -- but calling qmake plugin.pro creates it. Once that's done, calling make will create the library //libFreeCAD_widgets.so//. To make this library known to your Qt Designer you have to copy the file to //$QTDIR/plugin/designer//.