Getting release version
You can get the release version of OOFEM from its download page. After downloading, unpack the distribution.
* In case of tar .tar.gz files you can use, for example, following command
gunzip -c oofem-x.y.tar.gz | tar xof -
* In case of .zip files use
Getting development version
Alternatively, you can get the bleeding edge version of OOFEM from the OOFEM Git repository.
This step requires Git to be installed on your system (see our Git tutorial for more info).
To grab a copy of the latest version of OOFEM using public git access, use following command:
# When a repository is cloned, git automatically creates a master branch that tracks origin/master
git clone http://www.oofem.org/git/oofem.git oofem.git
# If you would like to track develop branch
git checkout -b develop origin/develop
The oofem.git directory has been created with OOFEM source tree.
Once you've checked out a copy of the source tree, you can update your source tree at any time so it is in sync with the latest and greatest by entering your oofem directory and running the command:
git fetch origin
Be aware, however, that develop branch of the code is not guaranteed to be stable. This option is intended mainly for active oofem developers, giving access to the most up-to-date version.
Unix / Linux Installation
Installation on Ubuntu system (9.10 Karmic and later)
Pre-build packages are available in the PPA for Václav Šmilauer.
deb http://ppa.launchpad.net/eudoxos/ppa/ubuntu karmic main
deb-src http://ppa.launchpad.net/eudoxos/ppa/ubuntu karmic main
sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 92DE8183
sudo apt-get update && sudo apt-get install oofem oofem-mpi oofem-oofeg oofem-doc
sudo apt-get install build-essential xorg-dev
mkdir -p ~/build/debug/
cd ~/build/debug; make
mkdir -p ~/build/release/
cmake -DCMAKE_BUILD_TYPE=Release ~/oofem.git/
To make configuration options, either use the ncurses interface
ccmake or the graphical interface
cmake-gui or supply additional commands directly
cmake -DCMAKE_CXX_FLAGS="-Werror" ~/oofem.git
Some common build options
CMAKE_BUILD_TYPE specifies between Debug, Release
CMAKE_CXX_FLAGS="flags" allows to specify compiler flags
USE_DSS="ON" will include sparse direct solver.
use this option to compile with IML++ (template library for iterative methods). This requires to download and install IML library
. The iml sources are supposed to be located in directory dir.
USE_OOFEG="ON" configures and later builds built-in graphical post-processor called oofeg. Requires X-Windows, Ckit, and Elixir libraries to be installed.
USE_PARALLEL="ON" configures parallel support in oofem.
If you want to use ParMETIS, use USE_PARMETIS="ON".
Follow this link
for pre-requisities and installation instructions.
If you want to use PETSc library use USE_PETSC="ON" together with MY_PETSC_DIR=dir and MY_PETSC_ARCH=arch options to configure PETSC support (dir is the path to PETSC installation directory, arch is PETSC architecture. See PETSC installation manual for details.)
Full list of configure options can be obtained running 'ccmake' or any other CMake GUI. See the CMake page for more details.
Run make to compile the required targets as:
cd ~/build/target; make
Supply valid target directory (as set up in configuration)“.
The target executable will be created in ~/build/target directory.
Verifying installation - running tests
To test solver compiled under “target_name” target, change working directory to target directory:
Run ctest to run the internal tests (takes a while)
Running specific tests
You can run specific tests by using the -R flag for ctest
ctest -R spring
or for example, only the parallel tests (only availble when parallel support is compiled)
ctest -R partest
There are also two custom targets added, “tests” and “benchmarks” which can be accessed
which only runs the mandatory tests and the optional benchmark examples respectively.
These custom targets are also accessible from KDevelop, Visual Studio and other IDEs.
is a Linux-like environment for Windows including a port of X Window System
is is a full-featured Integrated Development Environment (IDE) for the C/C++ programming language. It uses Mingw port of GCC (GNU Compiler Collection) as its compiler. It creates native Win32 executables. Dev-C++ is Free Software.
is the cross-platform build tool OOFEM uses, and is able to generate build files for Visual Studio. See further instructions on the CMake
is the most intuitive Git client for Windows.
is a good and free replacement for oofeg under Windows.
Windows installation under MinGW environment
MinGW uses standard GNU g++ compiler. In a standard MinGW instalation, a few libraries included in oofem are missing (sys/resource.h, execinfo.h). These are not included during cmakeing and compilation for MinGW compilation.
Under Windows, install mingw
including C, C++ and MSys as a terminal.
You may want installing windows version of Git
. Getting the development version of oofem is through a command
$git.exe clone http://www.oofem.org/git/oofem.git oofem.git
Install the latest version of cmake
Run a batch at C:\Program Files\mingw-w64\i686-6.3.0-posix-dwarf-rt_v5-rev1\mingw-w64.bat, it sets up a PATH to mingw32-make.exe and opens a new terminal. Do not close it.
In that terminal run graphical CMake: “C:\Program Files\CMake\bin\cmake-gui”.
In CMake set up a path to your oofem.git folder (Browse Source button).
Create a new project folder (e.g. build) and set up a path to it (Browse Build button). Put a tick in “Advanced” checkbox and then click Configure. A new window appears. Specify the generator “MinGW Makefiles” and “Use default native compilers”, click Finish.
Select packages and modules you want to use (or just keep the default settings). Write string “RELASE” (with capitals) or “DEBUG” in CMAKE_BUILD_TYPE. Uncheck “USE_SHARED_LIB”. Hit Configure again and then click Generate.
is required to read input files for CEMHYD3D module. TinyXML2 can be installed. For windows it needs to be compiled into a shared library libtinyxml2.dll. Proceed in a standard way for cmake files. Create a new subdirectory , e.g. target
. Under target
$cmake.exe -G "MinGW Makefiles" ..
a few times. Cmake starts to complain about a missing RC compiler. Edit CMakeCache.txt and edit line specifying RC compiler, to make e.g. CMAKE_RC_COMPILER:FILEPATH=c:/MinGW/bin/windres.exe. Run
$mingw32-make.exe. A shared library is created. To compile oofem with CEMHYD and TinyXML2 support, run
$cmake.exe -G"MinGW Makefiles" -DUSE_CEMHYD="ON" -DTINYXML2_DIR="/c/oofem/tinyxml/" ..
If oofem.exe complains about missing libtinyxml2.dll, add the location to the system path or copy libtinyxml2.dll in the same directory as oofem.exe.
Close CMake, but do not close the terminal. Open your project folder, e.g. cd C:\OOFEM\build
Type mingw32-make -j3 to compile oofem using 3 cores. (Building release took approx. 15 minutes.)
In case of error caused by multiple definition of 'vsnprintf' add -D__USE_MINGW_ANSI_STDIO=0 in CMAKE_CXX_FLAGS and regenerate makefiles.
Run oofem tests: “mingw32-make tests -j3” and benchmarks “mingw32-make benchmarks -j3”
The size of oofem with debug options is approx 740 MB
, release 10.2 MB
In order to use oofem on a different computer it is essential to transfer all *.dll's from MinGW/bin alonside oofem. Copy them in the same folder as oofem.exe (8 files, 3.5 MB
Windows installation with Visual Studio
Visual Studio 2013 is advised, since it fully supports C++11 specifications, see here
. You can use the Express for Windows Desktop edition, freely available here
Get oofem code from Git repository as explained previously or, if you're using TortoiseGit
, simply create a new folder (e.g.
), right-click on it and select
from the contextual menu. In the window that appears, use the address:
Start the VS2013 command prompt (choose x86 if you want a 32-bit compilation), and type
cmake-gui and press enter to load the graphic interface for CMake. The bin folder in CMake installation directory must in system path; if the command does not work, add it and restart the prompt.
In the CMake window, insert the path the previously downloaded oofem.git copy (e.g.
C:\oofem) in the fieds
Where is the source code: and
Where to build the binaries: and click
Configure twice. Select in the data line now displayed in the main panel all the packages you want to include in your built (
USE_… flags). You can also leave the default checks. Finally press
Generate and choose in the window that would appear
Visual Studio 12 2013 and
Use native compiler.
Now in the oofem folder (e.g.
C:\oofem) double-click on
oofem.sln to start VS; right-click on the
oofem project and click on
Set as StartUp Project. Compile the solution. You can find the resulting
oofem.exe inside the
For the best debugging experience in VS, please deselect
USE_SHARED_LIB in CMake to generate a monolithic executable.
There are different configurations for Debug and Release versions under VS→Configuration manager→Active solution configuration. Debug version is generally slower and contains debugging symbols. Users usually choose Release version which is optimized for speed.
If you plan to redistribute the OOFEM executable to Windows XP machines, you must set the property
Visual Studio 2013 - Windows XP (v120_xp) in
Configuration Properties\General\Platform Toolset from the
oofem project settings.
If you're interested in parallel version for Windows, go here.