General information and availability

1. What is the SALOME platform?
The SALOME platform is an open source software framework for pre- and post-processing and integration of numerical solvers from various scientific fields. CEA and EDF use SALOME to perform a large number of simulations, typically related to power plant equipment and alternative energy. To address these challenges, SALOME includes a CAD/CAE modelling tool, mesh generators, an advanced 3D visualization tool,  etc.
2. What are the rules for the modification and distribution of SALOME?

The SALOME platform is distributed under the GNU Lesser General Public License (LGPL) version 2.1. All products required by SALOME are distributed under the LGPL (or equivalent) or “free for non-commercial use” licence

3. Does SALOME provide a free open source solver?

SALOME provides SolverLab, which allows to solve partial differential equations. Other solvers dedicated to a specific domain are available in dedicated applications:

  • salome_meca integrates the code_aster solver dedicated to structures and thermomechanics analyses
  • salome_cfd integrates the code_saturne and neptune_cfd solvers dedicated to computational fluid dynamics (monophasic and multiphasic)

Other applications with non open-source codes are developed but not distributed on internet.

4. Which operating systems are supported by the SALOME platform?

SALOME is developed and qualified on Linux and Windows. SALOME is built and tested on different Linux platforms: Red Hat, CentOS 7 and 8, Debian 9 and 10, Ubuntu 18 and 20, Fedora. If specific binaries are not distributed for your Linux platforms, you can use the generic “universal” binaries. These binaries are built on the CentOS 7 platform. The libraries needed to make the binaries work on other, newer platforms are included in the archive.

5. What does SALOME mean?

SALOME is a French acronym which stands for  “Simulation numérique par Architecture Logicielle en Open source et à Méthodologie d’Évolution”. In English this translates to    “numerical simulation with evolving methodologies over open source computing architectures”.

Building and installing

1. What is SAT?

SAT is a tool used for maintenance and packaging of the SALOME platform. It facilitates the building on various Linux and Windows platforms of large software packages that rely on many prerequisites. The following features are supported:

  • definition of the application content: which products (prerequisites, codes, modules) are needed and which versions are required.
  • application configuration: how to get the source of the products, how to compile them, which options to use.
  • preparation of the complete software: all necessary sources with the right versions are retrieved from git/svn/cvs repositories, or from already prepared tarballs.
  • management of patches if some are needed to compile on specific platforms.
  • management of the environment to be set up at compile time and at run time.
  • automatic compilation of the complete application (the application with all its products).
  • production of a launcher that sets up the environment and starts the application.
  • packaging: creating binary and/or source packages to distribute the application on various platforms.

SAT is a Command Line Interface (CLI) based on the Python language. It is a suite of commands, which are detailed later in this documentation. These commands are used to perform operations on the application. SAT allows you to complete the commands using the provided complete_sat.sh script.

2. What are the prerequisites of SALOME?

The SALOME platform relies on a large number of third party products, including Python, Qt, sip, PyQt, boost, swig, Open CASCASDE Technology, qwt, omniORB, Hdf5, Paraview. Depending on the platform, some third party products are embedded in the SALOME tarball, others are directly provided by the system (native products installed with yum or apt).

3. What do I need to install on my workstation to run or build SALOME?

Before using or compiling SALOME for the first time, it is advisable to check if all the system requirements are installed. To do this, it is convenient to use the following SAT command, which will list the missing system dependencies:

./sat config SALOME-9.8.0 --check_system

For 3D visualization, it is recommended to use a dedicatied graphics card (NVIDIA or AMD RADEON), and to install the corresponding proprietary driver.

4. How to install SALOME on linux ?

First, download SALOME for your specific operating system version. If your OS is not supported, you can use the “universal version”.

Extract the archive.

Then, check that the dependancies are installed on your OS:

./sat config SALOME-9.8.0 --check_system

Check that your graphic card is well configured for 3D rendering.

Then launch SALOME with:


More information is  available in the README file.

5. How to install SALOME on Windows?

SALOME is built on Windows 10 with the Visual Studio 2017 compiler. It is important to choose a very short name for the installation directory, to avoid exceeding the PATH size limit (for example C:\SAL).

SALOME can be installed through an .exe install wizard or a .zip archive.

To launch the install wizard, double-click on it and follow the instructions. At the end of the installation, click on the launcher run_salome.exe to start SALOME.

If your company’s IT security policy forbid to install softwares with .exe files, we also provide SALOME in a .zip archive. To install it:

  • Create a directory of maximum 4 letters at the root of your disk (for example C:\SAL)
  • Go inside it and unzip SALOME;
  • Go to the directory created by the previous action;
  • Run SALOME by double-clicking on run_salome.bat or run_salome.exe or with command line.


6. How to get the source code of SALOME?

The SALOME source code is included in the SALOME packages as tarballs in the ARCHIVES directory. To install the source code in the SOURCE directory, use the command:

./sat prepare SALOME-9.8.0

The SALOME source code can also be retrieved directly from the git repositories. More information on the gitweb page.

7. How to compile SALOME?

The SALOME source code is included in the SALOME packages and can be compiled, either partially (one or more products) or completely. For more information, follow the instructions in the README file contained in the package.

Architecture of SALOME

1. How is CORBA used in SALOME?

SALOME is a distributed system, which means that all the functionality of the application is exposed as objects and that each object can use any of the services provided by other objects in the system, or even by objects in other systems. The SALOME platform uses the CORBA middleware to allow the distribution of components over remote resources. Therefore, most SALOME components are defined as CORBA servers and implement a CORBA interface. They can be launched either in a dedicated server, or integrated in the main SALOME process. This possibility is exploited by the YACS module to couple computational codes. SALOME components that do not need CORBA are written with the SALOME “light” configuration. This configuration provides a GUI framework to write classical one-process GUI applications (SALOME light components). These components can be run separately or run in the same session as the full classic components.

2. What is SALOME session-less (SSL)?

With increasingly powerful computers, CORBA is becoming less useful in SALOME, apart from YACS and the code coupling use cases. When CORBA is not needed, an optimised mode has been developed to avoid launching CORBA session server. This mode, called SSL, will be the default mode from SALOME 9.9. With this mode, all code is executed within the main SALOME process. The user does not need to “kill” the servers after using SALOME. Debugging and testing is also easier.

To use this session-less mode for launching python scripts:

  • either set the environment variable SALOME_EMB_SERVANT to 1. On Linux:

or on Windows:

  • or add in your python script:

To test this session-less mode in the graphic user interface (only for some module in SALOME 9.8), launch SALOME with:

./salome sessionless
3. What is a SALOME study?

The study is a document in the GUI, an abstraction layer between the actual data in the document (probably remote data available via CORBA) and the presentation of the data (in the Object Browser). It contains a tree of data object instances.

4. How do SALOME modules interact with SALOME study?

Each module can publish its data in SALOME study to allow other components to access it. Publishing in the Study also allows the persistence of this data through the “Save Study” menu. Note that the persistence of complex data can also be ensured by special methods, such as the “Save graph” of the YACS module.

Scripting SALOME with Python

1. What is the relationship between SALOME and Python?

All features developed in C++ are mapped to the Python API and can be executed with Python. SALOME uses python for its power and simplicity. This feature is the strengh of the SALOME platform and allows the creation of scripts and the automation of complex use cases. Writing SALOME’s Python scripts is made easier by the “Python dump feature”: the user experiments with complex actions in GUI mode and then dumps them into a Python script. He can then extend and parameterise then. This mode of working is very efficient.

2. How to use SALOME with Python?

The user has several possibilities. It is possible to :

  • run a script when launching the GUI:
    ./salome myscript.py
  • execute a script when launching SALOME in TUI mode:
    ./salome -t -w1 myscript.py

-t means text mode,

-w1 means kill CORBA servers at the end of the script.

  • load a python script inside the GUI, from the File menu.
  • execute Python commands in the GUI’s built-in Python window.
3. When should I use GUI or TUI?

It is possible to use both GUI and TUI while working with SALOME. The TUI interface is best suited for long calculations in batch mode. The results of the calculations can be checked using the GUI. The Python dump feature allows to experiment with actions with the GUI and to save these actions in a Python script, which can be replayed later. Advanced modules such as SHAPER are more suited to the GUI (especially the sketcher), but their actions can still be saved in Python scripts.


1. What is MEDCoupling?

MEDCoupling is the SALOME library for processing meshes and numerical fields (input and output data for field physics oriented simulation codes). It provides several powerful features, which can be divided into four categories:

  • Data movement: read/write from/to file, reduce, extract, duplicate, aggregate, compare, exchange data memory to memory across process.
  • Data analysis: extract/gather information in data to transform it into a condensed workable data (not necessarily field linked) for further use.
  • Data conversion: interpolate, project, repair, decimate, format conversion to couple multiple simulation codes.
  • Data optimization for simulation code : renumbering, partitioning for multiprocessor codes.

Data persistence is based on the .med format which is part of the medfile product. medfile specifies the field and mesh standard. The files are written with the hdf5 library and support parallelism.

2. Where can I find the documentation for the med file format?

The med file documentation is provided by the FIELDS module: menu Help/User’s Guide/FIELDS module/MedFile This documentation is written in French and presents in particular the connectivity reference within the “Guides d’utilisation” (User’s guide).

3. What is the purpose of the FIELDS module in SALOME?

The FIELDS module of SALOME provides the MEDCoupling library (a C++ library dedicated to the manipulation of meshes and fields consistent with the MED model) as well as a Graphical User Interface to access some common operations. It simplifies MED manipulations and also gives access to simplified MED Visualizations linked to the PARAVIS module. The module FIELDS provides the documentation of MEDCoupling and medfile libraries.


1. How to start a bash session with the SALOME environement?

Just run the command:

./salome context   # create a bash session with the SALOME environment

It is possible to use some standalone modules of SALOME independently of the others. For example, you can run SALOME paraview :

paraview   # run paraview provided by SALOME


2. How to use pip in SALOME?

Since version 9.4, SALOME uses pip to manage the Python modules included in SALOME. SALOME users can therefore customize their Python with the module of their choice. Start by setting the necessary environment variables for SALOME, run the following command:

./salome context # create a bash session with the SALOME environment 

Then one can use pip as intended. For example, to add a module h5py to SALOME via pip:

python -m pip install h5py==2.10.0 --no-dependencies

Similarly, to remove a module via pip  that is no longer needed

python -m pip uninstall h5py
3. How to remove the old residual process from SALOME?

When SALOME is started, it launches a CORBA server at the beginning which sometimes is not killed at the end. If you see old SALOME processes, it is possible to clean them up with the following command:

./salome killall

Under Windows, you must execute the command:

call kill_salome.bat


4. Is it possible to adjust the font size in SALOME?

Depending on your desktop environment, strings in SALOME can be too small or too large. This also affects the height of the icons. It is possible to adjust the font scale using the QT_FONT_DPI parameter. For example, to increase the size by 10%:

export QT_FONT_DPI=110


5. How to solve 3D display troubles?

For a good display of the 3D views, it is recommended to have a dedicated graphics card (Nvidia or AMD) and to install the proprietary driver from the package manager of your Linux platform.

For those who wish to use SALOME remotely (via ssh, virtual machine, etc), we recommend using the command ./mesa_salome rather than ./salome to launch SALOME.  The generic SALOME (./salome) uses OpenGL for 3D view rendering, however OpenGL  is not fully supported by the X11 transfer needed during remote sessions. To solve this problem, ./mesa_salome uses Mesa which is an alternative OpenGL implementation that enables you to use SALOME while not using your GPU driver. The performance of ./mesa_salome is downgraded, but this command is fully compatible with the generic SALOME (./salome).

If you need to work on a remote computer frequently, and do not want to sacrifice performance, we recommend using TurboVNC to launch a remote desktop and VirtualGL to use the remote graphic card: vglrun ./salome.

6. Can SALOME handle large data?

SALOME 9 has been enhanced to be able to handle large data sets. All modules (SMESH, PARAVIS, MEDCoupling) now support 64-bit integer arithmetics (int64), which makes it possible to manage large meshes. The SMESH module  has been optimized to display such meshes (multi-threading) and now includes very efficient meshing algorithms (such as Gmsh Hextreme).