# Open MPI: the consortium implementation behind most HPC message passing > The C and Fortran implementation of the MPI specification, maintained by a university and industry consortium, with a layered tree of opal, ompi, oshmem and a bundled third-party stack. **open-mpi/ompi** — Open MPI main development repository - Repository: https://github.com/open-mpi/ompi - Website: https://www.open-mpi.org - Stars: 2,663 · Forks: 1,006 - Language: C - License: NOASSERTION - Published: 2026-10-07 · Updated: 2026-10-07 · Language: en - Canonical page: https://hysenlabs.com/projects/open-mpi-ompi ## A README that is really a documentation pointer The whole README is worth quoting in outline because it is unusually short. It identifies the Open MPI Project as an open source implementation of the Message Passing Interface specification, developed and maintained by a consortium of academic, research and industry partners, and then says the point of the consortium is to combine expertise, technologies and resources from across the high performance computing community. It names three audiences: system and software vendors, application developers, and computer science researchers. After that it is documentation instructions, and there are exactly two ways to read the manual. The docs are online at docs.open-mpi.org, or self-contained in official distribution tarballs under `docs/_build/html/index.html` for viewing without a network connection. The README also warns developers who clone the Git repository that they will not have the HTML documentation and man pages by default and that they must be built, pointing at the Sphinx and Python prerequisites page. That split between source checkout and tarball is the practical takeaway. The clone is for people working on Open MPI; the tarball is for people building and installing it. ## What sits in the tree, layer by layer The file tree is where the actual information is, and it reads like a layered architecture: ```text 3rd-party/ config/ contrib/ docs/ examples/ ompi/ opal/ oshmem/ specs/ test/ ``` `opal/` is the operating layer: process management, environment variables, memory and the plumbing a parallel runtime needs before it can be an MPI library. `ompi/` is the MPI layer, the implementation of the API that applications actually call, and it also carries the test suite including `ompi/test/mpi-abi/`, which is where the ABI compatibility tests referenced by the requirements file live. `oshmem/` is one-sided memory, the partition-addressed model that MPI shared memory windows make possible. The remaining directories describe the work of shipping the thing. `3rd-party/` holds vendored dependencies, `config/` is the build system support, `contrib/` is everything that does not fit elsewhere, `examples/` is sample code, and `specs/` tracks the MPI specification versions the implementation targets. A `.gitmodules` file is present, and `autogen.pl` next to `configure.ac` and `Makefile.am` shows this is an autotools project rather than a CMake one. ## The signal in the newer root files Some entries in the tree say more about how the project works than the prose does. `HACKING.md` at the root is the contributor's entry point. `AGENTS.md` and `CLAUDE.md` sit alongside it, which is a clear signal that coding agents are expected to contribute to this codebase and that the project has written down rules for them. `.clang-format` at the root confirms the C and C++ sources have one formatting policy rather than per-directory conventions. The documentation tooling is configured explicitly, with `.readthedocs.yaml`, `.readthedocs-pre-create-environment.sh` and an `.nspect-allowlist.toml`. The last of those is worth pausing on: an allowlist file implies the docs build checks links and some destinations are knowingly excluded, which is the honest way to handle a documentation set that references external sites it does not control. The repository is hosted on GitHub, its language is recorded as C, and it carries 2,646 stars with 1,001 forks and 842 open issues. A fork count near half the star count is what you would expect from a project that distributions and HPC sites mirror and patch. The last push was on 2026-09-24, and the repository is not archived. The README shows no changelog, and the version lives in a `VERSION` file at the top level rather than in release notes. ## Python dependencies are for developers, not for installers The one file in the repository with real explanatory prose is `requirements.txt`, and it makes a distinction that saves newcomers a wasted afternoon: ```text -r docs/requirements.txt -r ompi/test/mpi-abi/requirements.txt ``` The header explains that this file is the union of all the `requirements.txt` files throughout the code base, and that installing all the Python packages from it, for example into a virtual environment, gives you what you need to run any of Open MPI's Python code. It then adds the caveat that these packages are typically needed only by those developing Open MPI itself, and that someone downloading a tarball to build and install it in order to run MPI applications probably does not need them. Two of the referenced files are named in the tree: documentation requirements and the requirements for the ABI test suite. That is the shape of the documentation and testing toolchain in one screen, and it is a small piece of design communication that many larger projects would benefit from copying. ## How this compares to what you might otherwise use MPI is an interface specification, not a program, so the useful comparison is between implementations rather than between MPI and something else. MPICH is the other long-lived implementation, with a different lineage and a different relationship to vendor support; Intel MPI and the vendor forks of both inherit from one or the other. Open MPI's distinguishing feature is the consortium structure, with academic and HPC site expertise in the same room as vendors, which shows up in the breadth of the supported platforms. It is also worth being clear about what Open MPI does not do. It is not a cluster scheduler: Slurm, PBS and Kubernetes handle allocation and process launch in most deployments, and the README frames vendors as the distribution path rather than pretending the project ships packages for every platform itself. And the README does not contain installation instructions at all, which is why the online docs and the tarball documentation bundle matter more here than in projects that put a one-line install command in their front page. Whether the docs settle your question depends on which question. Cluster setup, PMI versus PMIx, and the many network transports are documented off this page. What the repository itself settles is the layer structure, the build system, the contributor workflow and the fact that Python is a developer dependency. ## Conclusion Open MPI rewards a reader who knows what layer a problem lives in. Hardware discovery and process launch sit in `opal/`, the user-facing MPI bindings and the bindings' own tests sit in `ompi/`, one-sided memory is `oshmem/`, and the packaging for the third-party stack you did not write lives under `3rd-party/`. The README itself is two short sections about documentation, so for anything beyond what the project is and where its docs sit, the tree, `HACKING.md` and `docs.open-mpi.org` are the real entry points. The one judgement worth making early is whether you need to build from source at all, since the README frames vendors as the distribution path and treats a tarball build as the case for people actually running MPI applications. ## FAQ ### What is OpenMPI? The README identifies it as an open source implementation of the Message Passing Interface specification, developed and maintained by a consortium of academic, research and industry partners. The stated purpose of that consortium is to combine expertise, technologies and resources from across the high performance computing community, and the README names its audiences as system and software vendors, application developers, and computer science researchers. ### What is the difference between MPI and OpenMPI? MPI is the specification, a document maintained by the MPI Forum that defines the API for passing messages between processes in parallel programs. Open MPI is one implementation of that specification, written in C and Fortran. The README links to the specification at the MPI Forum and describes Open MPI as the consortium implementation of it, and mentions system and software vendors as one of the audiences it serves. ### How do I install OpenMPI? The repository README does not carry installation steps, and that is deliberate: it frames system and software vendors as the distribution path and describes official distribution tarballs as the way to build and install. It does say where the documentation lives, online at docs.open-mpi.org and inside tarballs under `docs/_build/html/index.html`. It also notes that cloning the Git repository gives you source without the built HTML docs or man pages, so a clone is aimed at developing Open MPI rather than using it. ## Sources - [Issues](https://github.com/open-mpi/ompi/issues) - [open-mpi/ompi on GitHub](https://github.com/open-mpi/ompi) - [Project website](https://www.open-mpi.org) - [README](https://github.com/open-mpi/ompi/blob/main/README.md) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/open-mpi-ompi