FIPS is a framework for simulating arbitrary particle dynamics written in and inspired by the Rust programming language. Unlike most other MD frameworks it does not make any assumptions on what kind of particle types, integration schemes or particle interactions you want. Instead, you can freely define any kind of numerical schemes you need in a domain-specific language and have FIPS do all the heavy-lifting for you. FIPS is specifically designed to run well on shared-memory systems while keeping the woes of parallel programming away from you. You can read more about the theory behind FIPS in this article.

In the following we assume that you are using a Linux system. Building FIPS for other platforms is not tested at the moment.

The only non-Rust dependency of FIPS is the LLVM Compiler framework. Here are the steps to installing it from source:

1. Install the required software for building LLVM. You can find a detailed list here.
2. Download the latest version of LLVM 14 from the website of the LLVM project. It is very important that you use version 14! FIPS is not (yet) compatible with versions above 14! We will assume version 14.0.6 in the following.
3. Unpack the release archive and switch to the source directory (note that this will also create a directory called cmake):

   tar xvf llvm-14.0.6.src.tar.xz
   cd llvm-14.0.6.src/

4. Create a build folder, switch into it and run CMake:

   mkdir build
   cd build
   cmake .. -DCMAKE_BUILD_TYPE=Release -DLLVM_ENABLE_ASSERTIONS=true -DCMAKE_INSTALL_PREFIX=/your/prefix/for/llvm

   Notes:
   • You can choose any empty folder as the install prefix for LLVM. In the following we assume that your normal user has write access to this folder.
   • We recommend enabling assertions as this can help us with debugging FIPS.
   • If CMake aborts with an error about a non-existent directory for benchmarks: This appears to be a bug in the build config of LLVM. You can fix it manually by going into build/CMakeCache.txt and turning every option that is related to benchmarks to OFF.
5. Build LLVM by running Make:

   make -j4
   make install

   Note: Building LLVM can take a long time and consume a considerable amount of resources. If your computer can handle it, you can increase the number of concurrent build jobs by changing -j4 to higher numbers. Watch your RAM usage!

Once you have installed LLVM, using FIPS is very simple: Just create a new Rust project and add the crate fips-md to the list of dependencies in your Cargo.toml. FIPS is used as a library from within a normal Rust program. To make sure that FIPS finds your LLVM installation, you will have to set the following environment variable:

export LLVM_SYS_140_PREFIX=/your/prefix/for/llvm

If you are new to the Rust programming language, make sure to check out the excellent Rust Book for an introduction to the world of Rust.

Here are answers to some questions you might have:

FIPS is built as like a compiler, i.e., it parses particle types, particle interactions and simulation schemes you define in a domain-specific language, performs static analysis (e.g., to determine where to place synchronization barriers) and then generates LLVM IR code that is fed into the JIT engine of LLVM. It also contains implementations of common acceleration structures that are necessary to achieve reasonable performance levels.

As a software project, FIPS is still very young. While it technically allows you to run nearly any particle simulation you can imagine by building on top of Rust¹, we still think there is much potential for improvement to the usability of FIPS. To not restrict the future development, we consider the API of FIPS (which includes the DSL) to be preliminary. Until version 1.0 of FIPS, backwards compatibility will be secondary to usability.

To exploit the full capabilities of modern hardware you usually need to try and parallelize computation-heavy applications (such as particle simulations). However, parallel programming is notoriously hard to get right and often introduces subtle bugs in the form of race conditions into your program. The situation is particularly bad when it comes to a special class of race conditions called data races. In (Safe) Rust, great care was taken to design the language in such a way that these errors cannot ever occur, thus allowing you to create parallel programs without fear of running into them. This "fearless concurrency" was a major inspiration for the creation of FIPS and as such we pay it homage in the name of the software.