Trilinos is a collection of compatible software packages that support parallel linear algebra computations, solution of linear, non-linear and eigen systems of equations and related capabilities. The majority of packages are written in C++ using object-oriented techniques. All packages are self-contained, with the Trilinos top layer providing a common look-and-feel and infrastructure.


The version 8.0 general release contains 30 packages: Amesos, Anasazi, AztecOO, Belos, Didasko, Epetra, EpetraExt, Galeri, IFPACK, Isorropia, Kokkos, Komplex, LOCA, Meros, ML, Moertel, MOOCHO, New_Package, NOX, Pliris, PyTrilinos, RTOp, Rythmos, Sacado, Stratimikos, Teuchos, Thyra, Triutils, TrilinosCouplings, and WebTrilinos.

The limited release contains an additional 2 packages that are available in special situations by request. These are: Claps and Tpetra.

In addition to many new features across most packages, Trilinos Release 8.0 contains 3 packages that are being released for the first time:

  • Belos (next-generation iterative solvers)
  • Sacado (automatic differentiation)
  • TrilinosCouplings (select Trilinos package interfaces)
Package-specific features for these new packages, as well as many of the other packages are listed below.

More information:

Trilinos website: http://trilinos.sandia.gov

New Make Targets

Trilinos now supports a large set of make targets. Prior to Trilinos 8.0, "make" built libraries, tests, and examples. Starting with Trilinos 8.0, "make" builds only libraries. Tests can be compiled using "make tests", and examples using "make examples". To build libraries, tests, and examples, the "make everything" make target can be used. Below is a listing of new and modified make targets that will be most useful to users:

make - Builds just the libraries
make install - Installs just the libraries
make examples - Makes just the examples (assumes libraries are built)
make install-examples - Install the examples (assumes libraries are installed)
make tests - Makes just the tests (assumes libraries are built)
make everything - Builds libraries, tests, and examples
make install-everything - Installs libraries and examples

Shared Libraries

There is now rudimentary, experimental support for shared libraries under Linux and Mac OS X. Shared versions of Trilinos libraries are now required for the PyTrilinos package, so this is where the shared libraries are built. However, it is not necessary to enable the PyTrilinos package to build the shared libraries. Also, shared libraries are built for ALL enabled packages, not just those with python interfaces. To enable shared libraries without enabling PyTrilinos, use the configuration option


Note that the build system for building shared libraries employs python, so this must be installed. However, the other PyTrilinos prerequisites -- swig and numpy -- are not required for building shared libraries. The resulting shared libraries are stored in your build directory in the sub-directory


and are installed in the same directory in which the static libraries are installed. Note that these shared libraries are considered EXPERIMENTAL. Only those shared libraries that are linked to PyTrilinos extension modules get tested. The other shared libraries might possibly have unresolved symbols. Please report any problems.

To get shared libraries to work, it may be necessary to manually add position-independent code options to the compiler flag variables. This is not necessary on Mac OS X or some flavors of Linux, because position-independent code is the default. However, on those Linux versions for which this is not the default, and on 64-bit systems, you will need to add these compiler options. For example, if the proper option for your compiler for position-independent code is "-fPIC", then your configuration invocation should include


There is a standing feature request that this be done automatically, but it has not been implemented yet.


  • KLU and BTF have been upgraded to version 1.0.


The Trilinos 8.0 release will contain the first public release of the Belos iterative linear solver package. Belos provides next-generation iterative linear solvers and a powerful linear solver developer framework. This framework includes
  • Abstract interfaces to linear algebra allowing the user to leverage any existing investment in their description of matrices and vectors. Linear algebra adapters are included for Epetra and Thyra.
  • Abstract interfaces to orthogonalization; implementations of iterated classical Gram-Schmidt (ICGS), classical Gram-Schmidt with a DGKS correction step, and iterated modified Gram-Schmidt (IMGS) are included.
  • Abstract interfaces to iteration kernels; implementations of conjugate gradient (CG), block CG, block GMRES, pseudo-block GMRES, block flexible GMRES, and GCRO-DR iterations are included.
  • Powerful solver managers are provided for solving a linear system using CG or block CG, GMRES or block GMRES with restarting, pseudo-block GMRES for performing single-vector GMRES simultaneously on multiple right-hand sides, and a single-vector recycled Krylov method (GCRO-DR).
  • Basic linear problem class is provided for the user to define a unpreconditioned or preconditioned (left, right, two-sided) linear system for Belos to solve.
  • Many examples for solving unpreconditioned, preconditioned linear systems with one or multiple right-hand sides using all the Belos solver managers.

Epetra 3.6

  • Epetra contains a new class called Epetra_VbrRowMatrix that completely supports the use of an existing Epetra_VbrMatrix object via the Epetra_RowMatrix interface. This new class addresses the fact that it is impossible to fully support Epetra_RowMatrix directly with Epetra_VbrMatrix (having Epetra_VbrMatrix inherit from Epetra_RowMatrix), so this new class should be used.


  • Miscellaneous improvements for Thyra support.

Pliris 1.2

  • A problem with a large number of multiple Right Hand Sides has been addressed and a fix implemented.

PyTrilinos 4.0

PyTrilinos is now a single, self-contained package again. For the most part, this affects developers more than users, with one exception. The PyTrilinos package is enabled with the configuration option


rather than the previous option, --enable-python, which had the effect of enabling python support within each package that provided wrappers. Individual PyTrilinos package wrappers can be enabled or disabled with


where "package" refers to a specific Trilinos package.


Sacado is a set of automatic differentiation tools for C++ applications. It provides templated classes for forward, reverse and Taylor mode automatic differentiation.

Sacado contains several basic AD classes:

  • Forward mode AD with the number of derivative components chosen at run-time: Sacado::Fad::DFad (most flexible)
  • Forward mode AD with the number of derivative components chosen at compile-time: Sacado::Fad::SFad (most efficient)
  • Forward mode AD with the maximum number of derivative components chosen at compile-time but actual number used chosen at run-time: Sacado::Fad::SLFad (sits between Sacado::Fad::DFad and Sacado::Fad::SFad in flexibility and efficiency)
  • Reverse mode: Sacado::Rad::ADvar
  • High-order univariate Taylor polynomials: Sacado::Tay::Taylor


  • New Belos wrappers (Belos released for first time in Trilinos 8.0).


Name change from Teuchos::RefCountPtr to Teuchos::RCP.

The name of the class Teuchos::RefCountPtr has been changed to Teuchos::RCP and the file Teuchos_RefCountPtr.hpp is not Teuchos_RCP.hpp. You can update all of you C++ code automatically and safely using the script:


Please see the header of this script for instructions.

If you choose not to refactor your code (e.g. by running the above script on it) then you can take your chances and just include the backward compatibility file Teuchos_RefCountPtr.hpp. However, this is *not* recommended because this file uses a terrible macro that is dangerous to have.

Improved parameter validation support


  • Improved support for implicit linear operators with object labels and other improvements.
  • Various miscellaneous improvements and additions.

TrilinosCouplings (new)

TrilinosCouplings is a new package that was created as a place to put select interfaces between Trilinos packages. The code for the Trilinos 8.0 release was all taken from existing packages. Currently there is code for interfaces between Ifpack and ML, and ML and NOX.

The following packages did not report any significant feature updates for Trilinos 8.0:

Anasazi, Aztecoo, Didasko, EpetraExt, Galeri, Ifpack, Isorropia, Kokkos, Komplex, LOCA, Meros, ML, Moertel, New_Package, NOX, RTOp, Rythmos, TriUtils, WebTrilinos

Known Issues

Sacado does not build on the Sun platform with no known workaround. See bugzilla bug 3586 for more information.

The test for TrilinosCouplings is currently not functioning. Changes need to be made to the configuration for the package to fix this issue. We plan to address this in one of the first release updates. On many machines this test will fail in mpi, in other cases, the test will simply output a message and exit.

We are aware of a number of other minor, platform-specific test failures:

Linux (mpi):
         Anasazi - BlockDavidson_test.exe (12 processors)
         PyTrilinos - exMLAPI_Simple.p
         PyTrilinos - exMLAPI_Smoother.py
         PyTrilinos - testML_Preconditioner.py
         TrilinosCouplings - ml_nox_1Delasticity_example.exe

Linux (serial):
         Belos - gcrodr_hb.exe
         PyTrilinos - exAztecOO_RowMatrix.py
         PyTrilinos - exNOX_1Dfem.py
         Rythmos - basicExample_amesos.exe

Mac (mpi):
         Meros - testEpetraThyra.exe
         ML - ml_user_smoothing.exe

Mac (serial):
         Meros - testEpetraThyra.exe