ParaView:Build And Install
This page is being updated for upcoming ParaView release (4.0 Alpha). For ParaView 3.14.1 and earlier versions, refer to the past version of this document.
Introduction
This page describes how to build and install ParaView. It covers both the released and the development versions, both Unix-type systems (Linux, HP-UX, Solaris, Mac), as well as Windows.
ParaView depends on several open source tools and libraries such as Python, Qt, CGNS, HDF5, etc. Some of these are included in the ParaView source itself (e.g. HDF5), while others are expected to be present on the machine on which ParaView is being built (e.g. Python, Qt, CGNS). Based on whether you want to build ParaView along with all the external tools it needs or you want to build the external tools yourself (or use versions already available on your system), there are two ways to build ParaView from source.
- To build ParaView complete with all the dependencies it needs, use the ParaView Super-Build instructions.
- To build ParaView source itself by providing existing installations/builds of the external depencies, typical for developers, use the instructions on this page.
Prerequisites
- The ParaView build process requires CMake version 2.8.8 or higher and a working compiler. On Unix-like operating systems, it also requires Make, while on Windows it requires Visual Studio (8 or later).
- Building ParaView's user interface requires Qt, version 4.7.* (4.8.* is recommended). To compile ParaView, either the LGPL or commercial versions of Qt may be used.
- In order to use scripting, Python is required [3].
Download And Install CMake
CMake is a tool that makes cross-platform building simple. On several systems it will probably be already installed. If it is not, please use the following instructions to install it. If CMake does not exist on the system, and there are no pre-compiled binaries, use the instructions below on how to build it. Use the most recent source or binary version of CMake from the CMake web site.
Using Binaries
There are several precompiled binaries available at the CMake download page.
On Unix-like operating systemsLet's say on Linux, download the appropriate version and follow these instructions: cd $HOME wget http://www.cmake.org/files/v2.8/cmake-2.8.8-Linux-i386.tar.gz mkdir software cd software tar xvfz ../cmake-2.8.8-Linux-i386.tar.gz
|
On Windows
On Windows, if you are not administrator
|
Build Your Own CMake
On Unix-like operating systemsDownload the source code: http://www.cmake.org/files/v2.8/cmake-2.8.8.tar.gz cd $HOME wget http://www.cmake.org/files/v2.8/cmake-2.8.8.tar.gz tar xvfz cmake-2.8.8.tar.gz cd cmake-2.8.8 ./configure --prefix=$HOME/software make make install
|
On WindowsTo build CMake on windows, a previous version of CMake is required. This can be downloaded from the Cmake download page: [4]. |
Download And Install Qt
ParaView uses Qt as its GUI library. Qt is required whenever the ParaView client is built.
- As stated above, the LGPL of Qt can be found at [5].
- For source code, use the latest stable version of qt-everywhere-opensource-src-VERSION.[tar.gz or zip or dmg]. If this gives you trouble, version 4.8.2 is known to work.
- For binaries, use the latest stable version of qt-PLATFORM-opensource-VERSION.[tar.gz or zip or dmg]. If this gives you trouble, version 4.8.2 is known to work. When downloading binaries, ensure that your compiler version matches the Qt compiler indicated.
Download And Install ffmpeg (.avi) movie libraries
When the ability to write .avi files is desired, and writing these files is not supported by the OS, ParaView can attach to an ffmpeg library. This is generally true for Linux. Ffmpeg library source code is found here: [6]
Download And Install MESA 3D libraries
ParaView uses the OpenGL graphics drivers and card from a user's workstation. When you want to run ParaView's servers on a platform that does not include hardware OpenGL support, you must use MESA to emulate this hardware in software. Mesa is open source, and it can be downloaded from here: [7].
There is a known problem with MESA version 7.8.2 and ParaView. This has been reported to the MESA team. Version 7.7.1 has been tested and seems to work correctly as well as 7.9.
Build as follows:
- make realclean
- make TARGET (for instance, make linux-x86-64)
Note - some platforms will complain during ParaView compiles about needing fPIC. In the configs directory, copy your platform file to another custom file, edit it, and add -fPIC to the compile lines. For instance, cp linux-x86-64 linux-x86-64-fPIC.
For more elaborate discussion on building with Mesa/OSMesa support, refer to ParaView And Mesa_3D.
Download ParaView Source Code
If you are trying to build a ParaView release, download it from the release page. For the development version, please follow the instructions below for checking it out from git.
Download The Release
Don't forget that you can always just download the binaries from the ParaView download page. This page contains binaries for several platforms and the source code for the releases.
Note: debian build
List of packages to build ParaView on Debian:
libphonon-dev libphonon4 libqt4-assistant qt4-dev-tools libqt4-core libqt4-gui qt4-qmake libxt-dev g++ gcc cmake-curses-gui libqt4-opengl-dev mesa-common-dev
With MPI (using openmpi, you can use any other flavour):
openmpi-common openmpi-bin libopenmpi-dev
With Python:
python2.5-dev
Checkout Development Version from git
Note that you may need to download and install a git client, here: [8]
On Unix-like operating systemsPrepare directory for download # mkdir $HOME/projects # cd $HOME/projects To download the source code # git clone git://paraview.org/ParaView.git ParaView # cd ParaView # git checkout -b trunk origin/master # git submodule init # git submodule update To update the code # git fetch origin # git rebase origin/master #git submodule update |
On WindowsWe recommend [msysgit|http://code.google.com/p/msysgit]. Msysgit provides an msys shell that has the appropriate environment set up for using git and it's tools. |
Configure ParaView With CMake
- Always use a separate build directory. Do not build in the source directory.
On Unix-like systems
mkdir $HOME/projects/ParaView-bin cd $HOME/projects/ParaView-bin ccmake $HOME/projects/ParaView3
About CCMake (Curses CMake GUI)
|
On Windows
About CMakeSetup (Windows CMake GUI)
|
ParaView Settings
| Variable | Description |
| BUILD_SHARED_LIBS | If ON, use shared libraries. This way executables are smaller, but you have to make sure the shared libraries are on every system on the cluster. |
| PARAVIEW_USE_MPI | Turn this to ON to enable MPI. Other MPI options will not be available until you turn this on. |
| MPI_LIBRARY | Path to the MPI library (such as /usr/lib/libmpi.so). Should be found by default, but you may have to set it. (see the note below) |
| MPI_EXTRA_LIBRARY | Path to extra MPI library (such as /usr/lib/libmpi++.so). If the MPI distribution is MPICH, this may not be found; in this case, it is ok for this variable to be set to MPI_EXTRA_LIBRARY-NOTFOUND. |
| MPI_INCLUDE_PATH | Path to MPI includes (such as /usr/include/mpi). Again, this should be found by default. |
| PARAVIEW_ENABLE_PYTHON | Makes Python client scripting and the Python programmable filter available. |
| PARAVIEW_BUILD_QT_GUI | Flag to enable/disable the building of the ParaView Qt-based client. This option is useful when building ParaView on server nodes or when we are only interested in the Python client, as it avoids building of the Qt client thus does not require Qt. ON by default. |
| QT_QMAKE_EXECUTABLE | Path to Qt's qmake executable (such as /usr/local/Trolltech/Qt-4.2.2/bin/qmake). CMake uses this to locate the rest of the required Qt executables, headers and libraries. |
| VTK_USE_CARBON | For Mac, this is the default. Neither X11 nor COCOA frameworks are supported. |
| VTK_OPENGL_HAS_OSMESA | Turn this to ON to enable MESA (i.e., software rendering). All mesa directory and file settings below depend on this flag. |
| OSMESA_INCLUDE_DIR | Set this to the include directory for MESA. |
| OPENGL_INCLUDE_DIR | Set this to the include directory for MESA. |
| OPENGL_gl_LIBRARY | Set this to the libGL.a or libGL.so file. |
| OPENGL_glu_LIBRARY | Set this to the libGLU.a or libGLU.so file. |
| OSMESA_LIBRARY | Set this to the libOSMesa.a or libOSMesa.so file. |
Note for MPI settings: If your MPI variables aren't set automatically (usually the case if the compiler wrapper [mpicxx] is not in the path or in some standard directory), toggle advanced options and set MPI_COMPILER variable to the full path of your mpi compiler (usually mpicxx), and configure. This should set all the required MPI variables. If not, then you might need to enter them manually.
If you get an error such as "mpi.h: no such file or directory" then set the CMAKE_C_FLAGS= -lmpi and the CMAKE_CXX_FLAGS= -lmpi++ . This is in addition to the MPI variables.
Finish Configuring ParaView
Using CCMake
|
Using CMakeSetup
|
Build ParaView
You can now build ParaView using the appropriate build system.
Using MakeCMake will now generate Make files. These make files have all dependencies and all rules to build ParaView on this system. You should not however try to move the build directory to another location on this system or to another system. Once you have makefiles you should be able to just type: make
make -j 4
|
Using Visual StudioCMake will now create Visual Studio project files. Before you open Visual Studio, be sure that the Qt .dlls are in your path. You should now be able to open the ParaView project (or workspace) file. Make sure to select the appropriate build type (Debug, Release, ...). To build ParaView, simply build the ALL_BUILD target.
|
Install ParaView
ParaView can be run directly from the build directory. That said, for production environments, it should be installed in some system location. For that purpose simply follow the instructions for "Distributing ParaView" and the unpack the generated archive at the appropriate install location.
Distributing ParaView
It is possible to create distribution binaries for ParaView using CPack, which is included in CMake. The packaged binary can be in any of the variable supported generator formats eg. DEB (debian packages), RPM (RPM Packages), NSIS (Null Soft Installer) etc. Please refer to [[9]] for a complete list.
CMake Variables
When building ParaView so that it can be distributed, in most typical cases, ensure that the values for the following CMake variables are set correctly.
| Variable | Value | Description |
| BUILD_SHARED_LIBS | ON | Enables shared libraries (unless you are sure you want to do static builds). |
| CMAKE_BUILD_TYPE | Release | Unless you want to end up with debug install, set this to Release. |
| PARAVIEW_USE_MPI | OFF | Unless you are taking extra steps to ensure that the clients have the required MPI libraries, set this to OFF, since ParaView does not include rules to package MPI. |
| PARAVIEW_ENABLE_PYTHON | OFF | Unless you are taking extra steps to ensure that clients have the required Python libraries/modules. |
| PARAVIEW_INSTALL_DEVELOPMENT | OFF/ON | To package development files so that people can build plugins/custom-apps using the installation. |
| PARAVIEW_BUILD_QT_GUI | ON/OFF | To enable building the Qt client. |
| PARAVIEW_INSTALL_THIRD_PARTY_LIBRARIES | ON | To enable bundling of third party libraries when using cpack. An example is Qt. |
PARAVIEW_EXTRA_INSTALL_RULES_FILE: Adding custom install rules
You can add additional install rules by writing a custom CMake file with install rules and then set PARAVIEW_EXTRA_INSTALL_RULES_FILE CMake variable to point to that file. ParaView process all install rules that have the COMPONENT set to either "Runtime" (for executables), or "RuntimeLibraries" (for shared libraries), or "BrandedRuntime" (for custom-application specific libraries/executables) only (and "Development" when PARAVIEW_INSTALL_DEVELOPMENT is TRUE). So you want to add your install rules with appropriate COMPONENT values in this custom CMake file.
e.g. you want to include mpilibs in the installation, in that case the custom install rules file could look something as follows:
<source lang="python">
INSTALL (FILES ${MPI_LIBRARY} ${MPI_EXTRA_LIBRARY}
DESTINATION ${PV_INSTALL_LIB_DIR}
COMPONENT RuntimeLibraries)
</source>
Generate Package
Following the configuration, simply run 'make' to compile and build.
|
On Unix-like operating systems To generate a tar ball, in the binary directory, simply run: cpack -G TGZ --config
{ParaViewBuild}/Applications/ParaView/CPackParaViewConfig.cmake
If PARAVIEW_BUILD_QT_GUI was OFF, then to generate a package consisting of the server executables alone, use the following command: cpack -G TGZ --config
{ParaViewBuild}/Applications/ParaView/CPackParaViewServersConfig.cmake
|
On Windows To generate a null-soft installer (requires [10]), in the binary directory, simply run: cpack -G NSIS -C Release --config
{ParaViewBuild}/Applications/ParaView/CPackParaViewConfig.cmake
If PARAVIEW_BUILD_QT_GUI was OFF, then to generate a package consisting of the server executables alone, use the following command: cpack -G NSIS -C Release --config
{ParaViewBuild}/Applications/ParaView/CPackParaViewServersConfig.cmake
|
|
On Mac To generate an app bundle that can be distributed, use: cpack -G DragNDrop --config
{ParaViewBuild}/Applications/ParaView/CPackParaViewConfig.cmake
If PARAVIEW_BUILD_QT_GUI was OFF, then to generate a tarball consisting of the server executables alone, use the following command: cpack -G TGZ --config
{ParaViewBuild}/Applications/ParaView/CPackParaViewServersConfig.cmake
|
- If packaging with PARAVIEW_INSTALL_DEVELOPMENT ON then the CPack config file will be called CPackParaView-DevelopmentConfig.cmake.
Miscellaneous Comments
- Don't untar the packaged tar ball over the build directory itself. You can always remove the build directory and untar the tar ball in its place.
- Don't use make install, as it may install more files than required.
- CMAKE_INSTALL_PREFIX is not applicable when using CPack and will have no effect.
- Build trees of ParaView on non-Windows systems, always have RPATH information embedded in the binaries. When a make install is performed or CPACK is used, all RPATH information is stripped from the binaries in the install tree. By default ParaView builds forwarding executables (launchers) that are installed in the bin directory. These binaries properly set up the environment to launch the equivalent executable in the lib/paraview-x.y directory.
- If you are compiling a MESA version of the ParaView server, start the server with the --use-offscreen-memory flag.
Notes
Compiling on the Mac
To compile on the Mac, follow the instructions for Unix. The recommended configuration settings are: BUILD_SHARED_LIBS=ON.
Environment Variables
If you build with shared libraries, you may have to add the Qt directory to you PATH environment variables to run ParaView. With Windows, one way to do so is to open up the environment variables dialog by clicking through Start|Control Panel|System|Advanced|Environment Variables. From that dialog, add a new user variable called PATH with a value of C:\Qt\4.6.3\bin. For other operating systems, add Qt/4.6.3/lib to your LD_LIBRARY_PATH environment variable.
