CompileOnUnix/ro

Pe distribuțiile linux recente, FreeCAD este în general ușor de complialt, deoarece toate dependențele sunt de obicei furnizate de managerul de pachete. În esență, implică 3 pași:
 * 1) Obținerea codului sursă al FreeCAD
 * 2) Obținerea dependențelor (depinde de pachetele FreeCAD)
 * 3) Configurați cu "cmake" și compilați cu "make"

Mai jos, veți găsi explicații detaliate ale întregului proces, unele build scripts, și particularitățile pe care le-ați putea întâlni. Dacă găsiți ceva greșit sau depășit în textul de mai jos (distribuțiile Linux se schimbă adesea) sau dacă utilizați o distribuție care nu este listată, vă rugăm să ne ajutați să o corectăm.

Obținerea sursei
Înainte de a putea să compilați FreeCAD, aveți nevoie de codul sursă. Există 3 moduri de a o obține:

Git
Cea mai rapidă și cea mai bună modalitate de a obține codul este clonarea repositorii git read-only acum găzduită pe GitHub (aveți nevoie de pachetul git instalat ):

Aceasta va plasa o copie a celei mai recente versiuni a codului sursă FreeCAD într-un nou director denumit "freecad-code".

Source package
Alternativ, puteți descărca un pachet sursă, dar acestea ar putea fi deja destul de vechi, deci este întotdeauna mai bine să obțineți cele mai recente surse prin intermediul git sau github.

Getting the dependencies
To compile FreeCAD under Linux you have to install all libraries mentioned in Third Party Libraries first. Please note that the names and availability of the libraries will depend on your distribution. Note that if you don't use the most recent version of your distribution, some of the packages below might be missing from your repositories. In that case, look in the Older and non-conventional distributions section below.

Skip to Compile FreeCAD

Debian and Ubuntu
On Debian-based systems (Debian, Ubuntu, Mint, etc...) it is quite easy to get all needed dependencies installed. Most of the libraries are available via apt-get or synaptic package manager.

If you already installed FreeCAD from the official repositories, you can install its build dependencies with this single line of code in a terminal: sudo apt build-dep freecad

either:
 * build-essential
 * cmake
 * python
 * python-matplotlib
 * libtool
 * libcoin80-dev (Debian jessie, stretch, Ubuntu 16.04 to 18.10)

or:
 * libcoin-dev (Debian buster, Ubuntu 19.04 and forward, as well as Ubuntu 18.04/18.10 with the freecad-stable/freecad-daily PPAs added to your software sources)

with Qt4 and Python 2 (for Debian jessie, stretch, Ubuntu 16.04):
 * libboost-dev
 * libboost-date-time-dev
 * libboost-filesystem-dev
 * libboost-graph-dev
 * libboost-iostreams-dev
 * libboost-program-options-dev
 * libboost-python-dev
 * libboost-regex-dev
 * libboost-signals-dev
 * libboost-serialization-dev
 * libboost-thread-dev
 * libeigen3-dev
 * libopencv-dev | libcv-dev
 * libgts-bin
 * libgts-dev
 * libkdtree++-dev
 * libmedc-dev
 * libproj-dev
 * libvtk6-dev | libvtk7-dev
 * libx11-dev
 * libxerces-c-dev
 * libzipios++-dev
 * lsb-release
 * swig
 * libqt4-dev
 * libqt4-opengl-dev
 * libqtwebkit-dev
 * libshiboken-dev
 * libpyside-dev
 * python-dev
 * python-pivy
 * python-ply
 * python-pyside
 * pyside-tools
 * qt4-dev-tools

or with Qt5 and Python 3 (Debian buster, Ubuntu 19.04 and forward, as well as Ubuntu 18.04/18.10 with the freecad-stable/freecad-daily PPAs added to your software sources:
 * libqt5opengl5-dev
 * libqt5svg5-dev
 * libqt5webkit5-dev or qtwebengine5-dev
 * libqt5x11extras5-dev
 * libpyside2-dev
 * libshiboken2-dev
 * pyside2-tools
 * python3-dev
 * python3-pivy
 * python3-ply
 * python3-pyside2.qtcore
 * python3-pyside2.qtgui
 * python3-pyside2.qtsvg
 * python3-pyside2.qtwidgets
 * python3-pyside2uic
 * qtbase5-dev
 * qttools5-dev

either:
 * libocct*-dev (official opencascade version, up-to-date, available in Debian buster and Ubuntu 18.10 and forward, as well as Ubuntu 18.04 with the freecad-stable/freecad-daily PPAs added to your software sources)
 * occt-draw

or:
 * liboce*-dev (opencascade community edition, outdated, available in Debian jessie, stretch, Ubuntu 16.04 and forward)
 * oce-draw

Note that liboce*-dev includes the following libraries: You may have to install these packages by individual name.
 * liboce-foundation-dev
 * liboce-modeling-dev
 * liboce-ocaf-dev
 * liboce-visualization-dev
 * liboce-ocaf-lite-dev

Optionally you can also install these extra packages:
 * libsimage-dev (to make Coin to support additional image file formats)
 * checkinstall (to register your installed files into your system's package manager, so you can easily uninstall later)
 * python-matplotlib
 * doxygen and libcoin80-doc (if you intend to generate source code documentation)
 * libspnav-dev (for 3Dconnexion devices support like the Space Navigator or Space Pilot)

Single command for Qt5 and Python 3 (requires Pyside2 available in Debian buster and the freecad-stable/freecad-daily PPAs)

Single command for Qt4 and Python 2

Ubuntu 16.04 users please see also these Additional instructions.

Fedora
You need the following packages :


 * gcc-c++ (or possibly another C++ compiler?)
 * cmake
 * doxygen
 * swig
 * gettext
 * dos2unix
 * desktop-file-utils
 * libXmu-devel
 * freeimage-devel
 * mesa-libGLU-devel
 * OCE-devel
 * python
 * python-devel
 * python-pyside-devel
 * pyside-tools
 * boost-devel
 * tbb-devel
 * eigen3-devel
 * qt-devel
 * qt-webkit-devel
 * ode-devel
 * xerces-c
 * xerces-c-devel
 * opencv-devel
 * smesh-devel
 * coin3-devel

(if coin2 is the latest available for your version of Fedora, use packages from http://www.zultron.com/rpm-repo/)
 * soqt-devel
 * freetype
 * freetype-devel

And optionally :


 * libspnav-devel (for 3Dconnexion devices support like the Space Navigator or Space Pilot)
 * pivy ( https://bugzilla.redhat.com/show_bug.cgi?id=458975 Pivy is not mandatory but needed for the Draft module)

Gentoo
Easiest way to check which packages are needed to compile FreeCAD is to check via portage:

emerge -pv freecad

This should give a nice list of extra packages that you need installed on your system.

If FreeCAD is not available on portage, it is available on the waebbl overlay. The issue tracker on the waebbl overlay Github may help guide through some issues you may come across. The overlay provides freecad-9999, which you can choose to compile, or simply use to get the dependencies.

layman -a waebbl

Tumbleweed
The following commands will install the packages required for building FreeCAD with Qt5 and Python 3.

The following command will install Qt Creator and the GNU Project Debugger.

If any packages are missing, then you can check the Tumbleweed "FreeCAD.spec" file on the Open Build Service.

Also, check to see if there are any patches you need to apply (such as 0001-find-openmpi2-include-files.patch).

Leap
If there is a difference between the available packages on Tumbleweed and Leap, then you can read the Leap "FreeCAD.spec" file on the Open Build Service to determine the required packages.

Arch Linux
You will need the following libraries from the official repositories:


 * boost-libs
 * curl
 * hicolor-icon-theme
 * libspnav
 * opencascade
 * python2-matplotlib
 * shared-mime-info
 * xerces-c
 * boost
 * cmake
 * desktop-file-utils
 * eigen
 * gcc-fortran
 * swig

Also, make sure to check the AUR for any missing packages that are not on the repositories, currently:
 * coin
 * python2-pivy
 * python2-pyside
 * python2-pyside-tools
 * python2-shiboken
 * qtwebkit
 * med (Modelisation et Echanges de Donnees)

Older and non-conventional distributions
On other distributions, we have very few feedback from users, so it might be harder to find the required packages. Try first locating the required libraries mentioned in Third Party Libraries. Beware that some of them might have a slightly different package name in your distribution (such as name, libname, name-dev, name-devel, etc...).

You also need the GNU gcc compiler version equal or above 3.0.0. g++ is also needed because FreeCAD is completely written in C++. During the compilation some Python scripts get executed. So the Python interpreter has to work properly. To avoid any linker problems during the build process it is also a good idea to have the library paths either in your LD_LIBRARY_PATH variable or in your ld.so.conf file. This is normally already the case in recent distributions.

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

Pivy
Pivy is not needed to build FreeCAD or to run it, but it is needed for the Draft module to work. If you are not going to use that module, you won't need pivy. By November 2015 the obsolete version of Pivy included with FreeCAD source code will no longer compile on many systems, due to its age. If you cannot find Pivy in your distribution's packages repository or elsewhere, you can compile pivy yourself:

Pivy compilation instructions

Compilare FreeCAD
FreeCAD uses CMake as its main build system. CMake is a build system available on all major operating systems. Compiling with CMake is usually very simple and happens in two steps.


 * 1) CMake checks that every needed program and library is present on your system, and configures the build system for the second step. FreeCAD has several configuration options to choose from, but it comes with sensible defaults. Some alternatives are detailed below.
 * 2) The compilation itself, which produces the FreeCAD executable.

Since FreeCAD is a heavy application, compiling can take a bit of time (about 10 minutes on a fast machine, 30 minutes (or more) on a slow one)

Out-of-source build
If you intend to follow the fast evolution of FreeCAD, building in a separate folder is much more convenient. Every time you update the source code, cMake will then intelligently distinguish which files have changed, and recompile only what is needed. Out-of-source builds are specially handy when using the Git system, because you can easily try other branches without confusing the build system. To build out-of-source, simply create a build directory, distinct from your FreeCAD source folder, and, from the build folder, point cMake (or if using cmake-gui replace "cmake" in the code below with "cmake-gui") to the source folder:

The FreeCAD executable will then reside in the freecad-build/bin directory.

In-source building
If you are unsure then, due to its limitations, do not make an in-source build, create an out-of-source build as explained in the next section. However FreeCAD can be built in-source, which means that all the files resulting from the compilation stay in the same folder as the source code. This is fine if you are just looking at FreeCAD, and want to be able to remove it easily by just deleting that folder. But in case you are planning to compile it often, you are advised to make an out-of-source build, which offers many more advantages. The following commands will compile FreeCAD:

In-source builds are fine if you are just looking at FreeCAD, and want to be able to remove it easily by just deleting that folder. However, if you are unsure where to build, do not make an in-source build. Create an out-of-source build as explained earlier. However FreeCAD can be built in-source, which means that all the files resulting from the compilation stay in the same folder as the source code.

The following commands will compile FreeCAD:

The FreeCAD executable will then reside in the freecad-source/bin directory.

How to repair your source code directory after accidentally running an in-source build.
This is a method, using Git, to repair your source code directory after accidentally running an in-source build.

The first line clears the .gitignore file. This ensures that the following clean and reset commands will affect everything in the directory and will not ignore items matching the expressions in .gitignore. The second line deletes all files and directories that are not tracked by the git repository, and then the reset will reset any changes to tracked files (including the first command which cleared the .gitignore file.

Configuration
By passing different options to CMake, you can change how FreeCAD is compiled. This can be useful for several purposes. For example, by calling CMake like this, you can instruct it to not build the FEM module:

All possible options are listed in FreeCAD's root CMakeLists.txt</tt> file. Try searching for the string OPTION</tt>. Alternatively, use the command cmake -LH</tt>. Below, we've listed some of the more relevant options you may want to configure.

To pass a value for an option you find in the CMakeLists.txt</tt> file, use the following flag: -D : =

External, or internal Pivy
If you want to use your system's copy of Pivy, which you most commonly will, then if not on Linux, set the compiler flag to use the correct pivy with -DFREECAD_USE_EXTERNAL_PIVY=1</tt>. Using external Pivy became the default for Linux, during development of FreeCAD 0.16, so it does not need to be manually set when compiling this version onwards, on Linux.

Building for Qt5
By default, FreeCAD builds for Qt4. It is possible to build for Qt5 by enabling the -DBUILD-QT5</tt> option.

Building for a specific Python version
By default, FreeCAD may only detect Python 2. It is possible to choose how to build for a specific version of Python (e.g. Python 2 or Python 3) by setting some cmake</tt> options. An example for Python 3 is shown below:

The locations and version numbers of your Python files and directories will be different depending on which distribution you are using. You can find them using the Unix locate</tt> or which</tt> commands.

Building with Qt Creator
To use Qt5 and Python 3, add the following to the bottom of: Projects → Manage Kits → Kits → Default (or your kit) → CMake Configuration:

The paths used for python depend on your system and might need to be changed. "python3 -m site" in a terminal will at least help with determining the site-package directory.

If you aren't using Python 3.7.x, you will need to replace the "3.7". From a terminal you can check with "python3 -V" and ignore the number furthest right.

Switch Projects → Run → Run Configuration from FreeCADMainCMD to FreeCADMain (unless you want the command line only version).

Qt designer plugin
If you want to develop Qt stuff for FreeCAD, you'll need the Qt Designer plugin that provides all custom widgets of FreeCAD. Go to:

So far we don't provide a makefile -- but calling

creates it. Once that's done, calling

will create the library libFreeCAD_widgets.so</tt>. To make this library known to Qt Designer you have to copy the file to $QTDIR/plugin/designer</tt>

Doxygen
If you feel bold enough to dive in the code, you could take advantage to build and consult Doxygen generated FreeCAD's Source documentation

Compilarea unui pachet Debian
Dacă intenționați să compilați un pachet Debian din surse, trebuie să instalați mai întâi aceste pachete:

To build a package open a console, simply go to the FreeCAD directory and call

Once the package is built, you can use lintian to check if the package contains errors

Note for 64bit systems
When building FreeCAD for 64-bit there is a known issue with the OpenCASCADE 64-bit package. To get FreeCAD running properly you might need to run the ./configure script with the additional define _OCC64 set:

For Debian based systems this workaround is not needed when using the prebuilt package because there the OpenCASCADE package is built to set internally this define. Now you just need to compile FreeCAD the same way as described above.

Scripturi automate de compilare
Aici este tot ceea ce aveți nevoie pentru o compilare completă a FreeCAD.Este o abordare cu un script și funcționează pe un distro nou instalat. Comenzile vor cere parola de root (pentru instalarea pachetelor) și cândva să or să recunoască o amprentă pentru un server de depozitare extern sau un repository de subversiune https.Aceste scripturi ar trebui rulați pe versiuni de 32 și 64 de biți. Ele sunt scrise pentru versiuni diferite, dar este de asemenea, probabil să ruleze pe o versiune ulterioară cu sau fără schimbări majore.

If you have such a script for your preferred distro, please send it! We will incorporate it into this article.

Ubuntu
These scripts provide a reliable way to install the correct set of dependencies required to build and run FreeCAD on Ubuntu. They make use of the FreeCAD Ubuntu PPA repositories, and should work on any version of Ubuntu targeted by the PPA. The 'daily' PPA targets recent versions of Ubuntu, and the 'stable' PPA targets all officially supported versions of Ubuntu.

This script installs dependencies for the daily development snapshot of FreeCAD.

This script installs dependencies for the latest stable release of FreeCAD. (For Ubuntu 12.04, omit "--enable-source" from the add-apt-repository command.)

(These scripts also install the PPA build of FreeCAD itself, as a side effect. You could then uninstall that while leaving the dependencies in place. However, leaving it installed will enable the package manager to keep the set of dependencies up to date, which is useful if you are following the development for a long time.)

After installing the dependencies, please see the generic instructions for getting the source code, running CMake, and compiling. The following script is an example of one way to do this.

OpenSUSE 12.2
No external Repositories are needed to compile FreeCAD 0.13 with this release. However, there is an imcompatability with python3-devel which needs to be removed. FreeCAD can be compiled from GIT similar to in OpenSUSE 12.2

Since you are using git, next time you wish to compile you do not have to clone everything, just pull from git and compile once more

Fedora 27/28/29
Posted by user [PrzemoF] in the forum.

{ echo "~/$MAIN_DIR already exist. Quitting.."; exit; } cd $MAIN_DIR git clone https://github.com/FreeCAD/FreeCAD.git mkdir $BUILD_DIR

Actualizarea codului sursă
Dezvoltarea programului FreeCAD se întâmplă rapid, în fiecare zi sau în repetate rânduri există bug-uri sau noi caracteristici. Sistemele cmake vă permit să actualizați inteligent codul sursă și să recompilați doar ceea ce sa schimbat, făcând compilații ulterioare foarte rapid. Actualizarea codului sursă cu git sau subversiune este foarte ușoară:

Deplasați-vă în directorul corespunzător de compilare și rulați din nou cmake (deoarece cmake actualizează datele versiunii de versiune pentru meniul Ajutor, ... despre FreeCAD), cu toate acestea nu trebuie să adăugați calea la codul sursă după "cmake", doar un spațiu și un punct:

Legături utile
Vezi și Compiling - Speeding up Cum se poate grăbi o compilare