New Fortran projects

Here is list of projects from Fortran Code on Github that were added since the beginning of September. I can update this monthly if there is interest. For brevity I have excluded projects from domain-specific categories such as Astrophysics or Earth Science. They are on the main list. Some “new” projects are years old but were only recently added.


cumsum_benchmark: benchmarks for the cumulative sum of an array, in Fortran, C++, Matlab, and Python, using various methods

Simple N-Body with LeapFrog integrator: Implementation in C, Fortran, Go, Julia and Rust of a very simple N-Body simulator with 3 particles using a LeapFrog integrator. Presented in What can the programming language Rust do for astrophysics?, to appear in the Proceedings of the IAU Symposium 325 on Astroinformatics.

Traveling Salesman Problem Exact algorithm: fastest to slowest are C++, Rust, Go, C#, Fortran, Dart, and Python, by Luis Harvey Triana Vega

Code Tools

adjac: automatic differentiation for generating sparse Jacobians, using Fortran 95 and operator overloading, by pv.

autodiff: automatic differentiation for up to 4th derivatives, by Simon Geard

fortran-git: Fortran 2008 ISO C binding interfaces to libgit2, by interkosmos

Fortran-RefCount: simple reference counting for Fortran

Compiler Tests

infnan: functions for checking Inf/NaN, Zaikun Zhang. They should work even if the compilers are invoked with aggressive optimization flags such as gfortran -Ofast .

File I/O

easy-netcdf: OOP Interface to the netcdf Fortran library, by onepieceze

Object-oriented Fortran 2018 HDF5 interface: very simple single-file/module access to HDF5, by fccf. More advanced object-oriented Fortran HDF5 access is also available but not compatible with HDF5 1.10 like this program.

HDF5 wrapper: minimalistic hdf5 wrapper for Fortran90/95, by Matthias Pickem

M_display: standard Fortran 95 module for printing scalars, vectors, and matrices to external files, by urbanjost. The module can display variables of default kind of all intrinsic types (integer, real, complex, logical, and character), and add-on modules are provided for data of the nondefault kind.

mo_netcdf: object-oriented wrapper around the NetCDF Fortran 90 interface, by David Schaefer et al.

NetCDF95: interface to the NetCDF library, by Lionel Guez. Compared to the Fortran 90 NetCDF interface, the NetCDF95 interface is meant to be friendlier and more secure, for example freeing the user from the cumbersome task of handling the error status.

oo_hdf: object-oriented Fortran HDF5 module, by Ricardo Torres. This library aims to create a group of classes in Fortran to interact with HDF5.

Fortran Books and Tutorials

OOP-Fortran-Examples: examples of using the object-oriented features in Fortran, taken from a presentation by Chris MacMackin at RSECon 2019

General Purpose

cernlib: large collection of general purpose libraries and modules maintained and offered in both source and object code form on the CERN central computers. Most of these programs were developed at CERN and are therefore oriented towards the needs of a physics research laboratory that is general mathematics, data analysis, detectors simulation, data-handling etc… applicable to a wide range of problems.

f90getopt: getopt()- and getopt_long()-like functionality (similar to the C-functions) for Fortran 90, by Hani Andreas Ibrahim

Fortran General Library (FGL): code for bitstrings, exception handling, hash tables, lists, logging, queues, strings, sorting, JSON parsing, and other topics, from mobius-eng

Fortran Equation Parser (feqparse): equation parser Fortran class that is used to interpret and evaluate functions provided as strings, by Joe Schoonover

fortran-list: generic list implementation in Fortran 2003, by Vladimír Fuka. Uses unlimited polymorphics or parametric polymorphism.

Fortran Logging Library: Flogging: provides an easy-to-use interface for logging events and errors in Fortran applications and libraries, by Chris MacMackin. Its use and functionality is similar to that of logging library in Python.

Fortran Parameter List (FPL): Fortran 2003 library that can manage the parameters of a program from a single point, by victorsndvg. FPL is an extendible container (dictionary) of <Key, Value> pairs, where the Key is a character string and the Value can be, by the default, of the basic data types.

Fortran User Defined Exceptions Handler (ForEx): Fortran 2003 project taking advantage of the C preprocessor capabilities in order to emulate exception handling, by victorsndvg

FortranUtilities: functions for strings, numbers, precision, statistics and files, by Emilio Castro

fstack: custom stack type for Fortran 2003 that implements a C-style stack, by jake-87. The advantage of this model is that one can have multiple stacks at any one time, so there is no need to juggle them – just allocate another one.

Futility: utilities for definition of kinds for intrinsic numeric data types, a unit test harness, definitions for some basic extensions to the Fortran language, geometry definitions and intersection routines, file wrapper functions, parallel wrapper functions, math utilities, a lightweight profiling interface, and other miscellaneous routines, from CASL

futility: collection of modern Fortran utilities, including some numerical subroutines and a module for simplified input and output of arrays, by Chris MacMackin

gFTL: provides a mechanism to easily create robust containers and associated iterators which can be used within Fortran applications, from Goddard-Fortran-Ecosystem. The primary methods are intended to be as close to their C++ STL analogs as possible. Also see gFTL-shared

Jumble: library of various utilities in Fortran 2003, by Lionel Guez

LinkedList: simple implementation of heterogeneous linked list in a single module, by Pedro Ricardo C. Souza

M_calculator: parse Fortran-like double precision scalar expressions, by urbanjost

M_hashkeys: collection of hash key generator modules, by urbanjost

M_history: input line history editor, by urbanjost

M_msg: convert all common variables to a string in Fortran using unlimited polymorphic variables, by urbanjost

M_path: creates an OOP (Object Oriented Programming) interface to other modules in the General Purpose Fortran package, by urbanjost.

It allows the typical components of a pathname on a POSIX system (Such as GNU/Linux, Unix and Cygwin) to be accessed easily, to render the full pathname of the path and to get basic file properties (permissions, size, ownership, …).

PolyCon: abstract container derived type which can be used as a sort of unlimited polymorphic entity whose contents are retrievable with type-guards, by Chris MacMackin. Different subclasses are created in order to hold different data-types.

Graphics, Plotting, and User Interfaces

cairo-fortran: libcairo bindings for Fortran from the gtk-fortran project available as a separate fpm package, by Carlos Une

M_ncurses: module that allows use of the C Ncurses library for controlling and formatting terminal displays, by urbanjost


MatlabFortran: easily export data from Matlab to Fortran and back, by Alessandro Di Nola

python-fortran: Python-Fortran bindings examples, by Pierre Navaro


Mean-preserving interpolation (mp-interp): implements four approaches for mean-preserving interpolation as might be applied, for example, to the interpolation of pseudo-daily values from monthly means, that when averaged, reproduce those monthly means, by Pat Bartlein

NdSpline: multidimensional spline interpolation based on the B-spline method, by Takayuki Miyagi. For details, see G. D. Knott, Interpolating cubic splines, Springer 2000.

Linear Algebra

ARPACK_PARPACK: solves large eigenvalue problems in double precision in standard Fortran 90, by KingJGod

blas-interface: interface declarations for basic linear algebra subprograms, by Sebastian Ehlert

Eigensolver_gpu: generalized eigensolver for symmetric/hermetian-definite eigenproblems with functionality similar to the DSYGVD/X or ZHEGVD/X functions available within LAPACK/MAGMA, by Josh Romero et al. This solver has less dependencies on CPU computation than comparable implementations within MAGMA, which may be of benefit to systems with limited CPU resources or to users without access to high-performing CPU LAPACK libraries.

libsparse: Fortran 2003 library that provides objects to create and handle rectangular and square sparse matrices using different formats: Linked List, COOrdinate storage (with elements stored using a hashing function), or Compressed Row Storage, by Jeremie Vandenplas. The library relies on different libraries, such as BLAS/LAPACK libraries, PARDISO (at this stage, Intel MKL PARDISO), and METIS 5.

LinAlgf90: modern Fortran wrappers for the eigenvalue functionality of Lapack, by Takayuki Miyagi

LUSOL: maintains LU factors of a square or rectangular sparse matrix. This repository provides LUSOL source code and a Matlab interface.

minila: lightweight, standalone set of common linear algebraic operations for vectors and matrices, by Gabriel Brown

moa-fortran: Mathematics of Arrays library for modern Fortran, by Wileam Y. Phan

Monolis: Morita’s non-overlapping / overlapping domain decomposition based linear equation solver. Has both a direct solver (LU) and many iterative solvers

Neural Networks and Machine Learning

Tangent-linear and adjoint test of a neural network (nn_tl_ad): fully-connected neural network implemented in Fortran, along with its “tangent-linear” and “adjoint” versions (i.e. the Jacobian and transpose of the Jacobian), by Sam Hatfield. It also includes standard tests for the consistency of these.


Field Abstract Calculus Type Usable and Aesthetic Library (FACTUAL): provides abstract types to represent mathematical fields in Fortran, by Chris MacMackin. These are both scalar and vector fields. It also contains (at present) one concrete implementation of these types, using a pseudo-spectral approach and tracking field values at Chebyshev collocation points.

forSISL: Modern Fortran interfaces to the SINTEF Spline Library (SISL), by Richard Weed

GetRootsF: routines for finding the roots of linear/non-linear equations, with or without derivative information, by Andrew Senchuk

Modern Fortran Utilities (ModForUtils): variety of tasks including computing binomial coefficients, factorials, routines for checking for NaN and Infinity floating point exceptions, root finders, random number utils and array sorters, and findloc, by Richard Weed. Future releases will expand on these utilities and add interpolation routines and other utilities.

NITSOL: Newton-iterative solution of large-scale nonlinear systems, by Homer F. Walker

QD: double-double and quad-double package for Fortran and C++, by Michael Orlitzky and X. Sherry Li

Numerical Integration (Quadrature)

FORbID: object-oriented Fortran 2008 library for numerical integration of definite integrals, by Giacomo Rossi and Stefano Zaghi


differential-evolution_f95: basic differential evolution optimization algorithm, by Ian Morrall

Differential Evolution Parallel Program (DEPP): designed to solve non-linear optimization problems of real-valued functions (objective functions) constrained to boxed domains, by gbertoldo. Additionally, this software is gradient-free, it is not code-invasive, i.e., objective function is treated as a “black-box”, it is tolerant to failures, to poor precision calculated or noisy objective functions, it uses parallelization, that is particularly useful for handling computationally expensive objective functions, and it allows a Response Surface Methodology-Differential Evolution hybridization for convergence acceleration.

Diver: fast parameter sampler and optimiser based on differential evolution, by Pat Scott et al.

Minpack: modernization of the original Fortran 77 code, by Jacob Williams

qnstop: suite of serial and parallel Fortran 95/2003 codes for deterministic global optimization and stochastic optimization by Layne Watson.

quadprog: quadratic programming routine based on R Package sources, by Pedro Ricardo C. Souza. Changed to have a Matlab like interface and usage examples in C and Fortran.

Parallel Programming

Advanced MPI and parallel I/O: Exercise material and model answers for the CSC course Advanced MPI and parallel I/O, by Jussi Enkovaara and Cristian-Vasile Achim

dmr: Fortran 2008 library for mimicking OpenMP device memory routines in Fortran, by Giacomo Rossi

Elements of high-performance computing: general level introduction to high-performance computing, from csc-training

Emulators: emulated collectives collection: collective subroutines and other procedures designed to emulate or extend standard language features, by Damian Rouson. Emulated features include the Fortran 2008 intrinsic function findloc and the Fortran 2018 collective subroutines co_sum and co_broadcast.

matmul_fortran_tensor_core: Example code for calling Tensor Core GEMM from Fortran, by Sam Hatfield

NVIDIA OpenACC Course Sources and Labs: contains sources related to the lectures and labs for the NVIDIA OpenACC course.

Particle-In-Cell Scalable Application Resource (PICSAR): high performance repository intended to help scientists porting their Particle-In-Cell (PIC) codes to the next generation of exascale computers. PICSAR exploits the three levels of parallelism that will be required to achieve good performances on future architectures: distributed memory parallelization (internode), shared memory parallelization (intranode) and vectorization.

Partial Differential Equations

ElliFEM: numerically solves the elliptic family of linear partial differential equations. Examples include the Poisson and Helmholtz equations. Reference: M. Drolia, et al. Enriched finite elements for initial-value problem of transverse electromagnetic waves in time domain. Computers & Structures, 182, 354-367, 2017.

PoisFFT: solves the Poisson equation on a uniform Cartesian grid using the Fast Fourier Transform, by Vladimír Fuka and Javier Alejandro Acevedo Barroso. It calls the library FFTW3 and (if MPI is used) also PFFT.

Spectral Element Libraries in Fortran (SELF): object-oriented Fortran library that support the implementation of Spectral Element Methods for solving partial differential equations, by Joe Schoonover. The SELF API is designed based on the assumption that SEM developers and researchers need to be able to implement derivatives in 1-D and divergence, gradient, and curl in 2-D and 3-D on scalar, vector, and tensor functions using spectral collocation, continuous galerkin, and discontinuous galerkin spectral element methods.

Random Number Generation

LEcuyer-RNG-Fortran90: pseudo-random number generator, more precisely, a combined multiple recursive generator (CMRG), MRG32k3a, proposed by L’Ecuyer “Good parameters and implementations for combined multiple recursive random number generators”. Operations Research. 1999 Feb;47(1):159-64, by p-serna. This algorithm is well suited for parallel computing as it can initialize many long streams and substreams, with a total period length of 2191 and it passes diehard tests.

pseudo_RNG_modules: pseudo-random number generator modules in Fortran, with option to compile as Python modules and some basic randomness tests in Python, from pointedsphere


amber: evaluate multivariate Bernstein polynomials for multivariate polynomial regression using de Casteljau’s algorithm, by R. Quast

sampleSTAT: command-line application to determine sampling distributions, by Hani Andreas Ibrahim. It goes a lot further than arithmetic mean and standard deviation.

SparseReg: Matlab toolbox for sparse regression calling Fortran code, by Hua-Zhou Hua Zhou and Brian Gaines

System of Sequential Assimilation Modules (sesam): perform the various basic operations that are required in sequential data assimilation systems. These operations include square root or ensemble observational updates (with global or local parameterization of the forecast error statistics), adaptive statistical parameterizations, anamorphosis transformations, or the computation of truncated Gaussian estimators.


M_match: basic implementation in Fortran of a subset of regular expressions as described in “Software Tools” by Kernighan and Plauger, 1976.

Unit Testing

FyTest — Instant Fortran unit testing: lightweight unit testing framework for Fortran, by Bálint Aradi. Thanks to its header-only design, it can be easily bundled with any Fortran project without creating extra dependencies.

Web Programming

Fortran + Apache + BSD + sqlite (FABS): web framework that leverages Fortran for the middle-tier, by bceverly. The client is a standard HTML5/CSS3/Javascript that talks to a REST API that is exposed by the Fotran middle-tier code via an Apache content filter using CGI.

fortran-machine: MVC web stack written in Fortran 90, by Nick Doiron et al.


Perhaps, you could add some further sub-sections to General Purpose, as there is not much structure. For instance, command-line parsing, data structures, databases, and data exchange formats.

1 Like

Excellent compilation @Beliavsky !
Thank you.
Yeah, it would be nice if it is updated every month.

1 Like

Update since Oct. 4, full list here

Art and Music

TapTempo Fortran: command line taptempo written in modern Fortran, by Vincent Magnin. Listen to a song and hit enter key with style and you’ll get the corresponding number of beats per minute (BPM).


Discrete Element Model Body (DEMBody): software for Granular Dynamics Simulation for Planetary Science and Geophysics, by Bin Cheng. It incorporates classical granular dynamics simulations and N-body self-gravity calculation.

ramses: models astrophysical systems, featuring self-gravitating, magnetised, compressible, radiative fluid flows. It is based on the Adaptive Mesh Refinement (AMR) technique on a fully-threaded graded octree.


Himeno Benchmark in Modern Fortran: Himeno benchmark to evaluate performance of incompressible fluid analysis code, written in Modern Fortran style, achieving almost the same execution performance as the original version, by Tomohiro Degawa. In this program, global variables are eliminated, and some variable names and subroutine names are refactored.

Biology and Medicine

ANCC: Python scripts and Fortran code for ambient noise tomography, such as computing cross-correlation (with parallel computing), and extracting dispersion curves, by Youshan Liu

Fortran Image Processing: processing, manipulating, and filtering CT scan data, by Nisarg Patel. A CT scan data could be binary RAW data or VTK data.

Climate and Weather

ExoRT: reasonably flexible two-stream radiative transfer code designed for use with 3D climate models, by Eric T. Wolf. In this software, contained are builds for a 1-D offline version, and for directly interfacing with CESM/CAM4.

Compiler Tests

AdHoc: archives ad hoc tests for modern Fortran compilers used by Sourcery Institute, Sourcery, Inc., their collaborators, sponsors, and clients. These tests emphasize support for the Fortran 2003 and 2008 standards along with features proposed for Fortran 2015 in technical specification TS 29113 Further Interoperability with C and the draft technical specification TS 18508 Additional Parallel Features in Fortran.

FCVS_95: modified version of NIST F77 validation suite, updated for Fortran 95. The original is FCVS.

Computational Chemistry

CoarseAIR: Fortran 2008 Code for State-to-State and Coarse-Grained Quasi-Classical Trajectory (QCT) Method. Reference: S Venturi - “Machine Learning and Uncertainty Quantification Framework for Predictive Ab Initio Hypersonics” - Ph.D. Thesis, University of Illinois at Urbana-Champaign (2021)

Donostia Natural Orbital Functional Software (DoNOFsw): performs computational chemistry calculations based on the Natural Orbital Functional Theory (NOFT), including PNOF5, PNOF6 and PNOF7. Correlation corrections after PNOF calculations can be estimated by second order perturbation theories.

linemake: atomic and molecular line list generator, by Chris Sneden et al. Rather than a replacement for a number of well-established atomic and molecular spectral databases, linemake aims to be a lightweight, easy-to-use tool to generate formatted and curated lists suitable for spectral synthesis work.

Computational Fluid Dynamics

AerOpt: aerodynamic optimisation code based on control node parameterisation, by Ben Evans et al.

channel: direct numerical simulation of an incompressible turbulent channel flow with two dimensional parallelization, by Davide Gatti

Fluid2d: versatile Python-Fortran CFD code that solves a large class of 2D flows, by Guillaume Roullet et al. It is designed to be used easily by Students learning Fluid Mechanics or Geophysical Fluid Dynamics and by their professors willing to illustrate their course and to organize numerical practicals.

Fluid Transport Accelerated Solver (FluTAS): modular, multiphysics code for multiphase fluid dynamics simulations. The code is written following a “functional programming” approach and aims to accommodate various independent modules. One of the main purposes of the project is to provide an efficient framework able to run both on many-CPUs (MPI) and many-GPUs (MPI+OpenACC+CUDA-Fortran).

KatzPlotkin: Fortran programs provided by Joseph Katz and Allen Plotkin in their book Low-Speed Aerodynamics

Earth Science

CoulombAnalysis: computes Coulomb stress changes induced by earthquakes, by jjwangw

sailing: sailing simulation based on CFSR wind and ocean current data, from ntu-as-cooklab. The goal is to simulate the sailing route of a sailing ship during different seasons based on a simple model, which may be helpful for studies on human migration across the ocean.

Semi-implicit Cross-scale Hydroscience Integrated System Model (SCHISM): community-supported modeling system based on unstructured grids and designed for the seamless simulation of 3D baroclinic circulation across creek-lake-river-estuary-shelf-ocean scales.

Tomofast-x v.1.2: parallel inversion platform to run single domain or joint inversion (gravity and magnetic data), by V. Ogarko and M. Jessell. It can use local weighting of gradient regularization function, global and local petrophysical constraints (Gaussian mixture model and multiple disjoint bound constraints).

Tracmass: Lagrangian trajectory code for ocean and atmospheric general circulation models, by Aitor Aldama and Kristofer Döös. The code makes it possible to estimate water paths, Lagrangian stream functions (barotropic, overturning, etc.), exchange times, etc.

Universal Boltzmann Equation Solver (UBER): solves the general form of Fokker-Planck equation and Boltzmann equation, diffusive or non-diffusive, that appear in modeling planetary radiation belts, by Liheng Zheng

File I/O

json-fortran-benchmarks: benchmarks for JSON Fortran parsers, by jacobwilliams. Also comparison to Python. Discussed here

fortran-yaml-cpp: YAML parser for Fortran matching the YAML 1.2 spec, by Nick Wogan. This package uses the C++ package yaml-cpp to parse yaml documents and then stores the data in Fortran derived types created by fortran-yaml.

Fortran Books and Tutorials

Intro-to-Fortran: materials for an online course by Chris Cooling

General Purpose

errorfx: simple library for demonstrating exception like error handling strategy in Fortran, by Bálint Aradi. It provides an error handling mechanism which is robust, convenient, and PURE.

FortranPatterns: Implementation of popular design patterns in Fortran, by Farhan J. Khan and zmiimz. This is intended to facilitate the community using Fortran for computationally expensive tasks. The main philosophy here is to make these patterns available for improving the reusability and efficiency of the code.

ftime: basic timing routines in Fortran 2003, by William C. Dawn

LinkedList: doubly linked list for Fortran 2003, by Tomohiro Degawa. The list is based on object-oriented programming, so the list can treat all types Fortran supports, including integer, real, character and derived types by using the unlimited polymorphism feature.

Graphics, Plotting, and User Interfaces

accis: plotting and graphics library by Ian Hutchinson. Related project: PLOTTRACES

fortran-motif: collection of ISO C binding interfaces to X/Motif, to create graphical user interfaces for Unix in Fortran 2008, by interkosmos. The library includes selected bindings to Xlib, Xt, Xm, and the XmHTML widget to render HTML 3.2 inside a Motif widget (optional).

fortran-xlib: collection of ISO C binding interfaces to Xlib for Fortran 2003, by interkosmos. Currently, only a subset of Xlib is implemented. In order to work with XPM files, interfaces to libxpm are included.


Fortran-Lua-hook library (flook): allows abstraction of input files to be pure Lua files to enable configuration of internal variables through an embedded Lua interpreter. Any valid Lua script can be executed from within any fortran application at points where the application creates Lua channels. Its main usage is the ability to change run-time variables at run-time in order to optimize, or even change, the execution path of the parent program.

Linear Algebra

JACSD: utilities for the Jacobi-type (G/H)SVD algorithms and beyond, plus a Cosine-Sine Decomposition tester, by Vedran Novaković. Associated projects here

Materials Science

hyplas: finite element program for implicit small and large strain analysis of hyperelastic and elasto-plastic two-dimensional and axisymmetric solids, from the book Computational Methods for Plasticity: Theory and Applications

Molecular Dynamics

Packmol: creates an initial point for molecular dynamics simulations by packing molecules in defined regions of space, from Martinez Molecular Modeling Group. The packing guarantees that short range repulsive interactions do not disrupt the simulations.


compare: module to aid in comparison of real or complex numbers, by Tom Canich and Magnus Hagdorn. The module specifies a tolerance when making the comparisons to determine equality or inequality.

Library of Numerical Analysis - Moscow State University: Translation of subroutines into modern Fortran (Fortran90 or higher) from Fortran 66.

Mittag Leffler function and its derivative: translated from the Matlab code of Robert Garrappa

NR_util: Fortran 2003 library by Lionel Guez containing basic mathematical constants and basic procedures for numerical tasks. NR_util originates from the “utility routines” of Numerical Recipes in Fortran 90 (Press et al., 1996, Cambridge University Press, appendix C1), version 2.10a, contained in files nrtype.f90 and nrutil.f90. These files of Numerical Recipes were put in the public domain by Press et al.

Numeric Library for Modern Fortran: scope: Integer (handling integer constants, digits, convert to string with format); Real (handling real constants, convert to string with format); Non-number (handling quiet nan and positive/negative inf as constants, check whether an array of floating-point numbers has at least one quiet nan, positive/negative inf value), by Tomohiro Degawa

SLATEC: comprehensive software library containing over 1400 general purpose mathematical and statistical routines, translated to modern Fortran by Mehdi Chinoune

Parallel Programming

code_examples: collection of examples showing peculiarities when working with Fortran, OpenACC, PGI, or any other software extensively used at MeteoSwiss

Hybrid CPU programming with OpenMP and MPI: exercise material and model answers for the CSC course, by Jussi Enkovaara and Martti Louhivuori

MPI-course: material for the course An introduction to parallel programming using Message Passing with MPI


Acceleration by Laser and Dynamics of charged particles (ALaDyn): particle-in-cell code firstly described in ALaDyn: A High-Accuracy PIC code for the Maxwell-Vlasov Equations by C. Benedetti et al., published on IEEE Transactions on Plasma Science, 36 4, 1790-1798 (2008) and then again in the update Charge preserving high order PIC schemes by P. Londrillo et al., published on Nucl. Instrum. Meth. A, 620 1, 28-35 (2010).

Angular Momentum model Of Relativistic Electron beam transport (AMoRE): code parallelized using OpenMP for fast simulations of laser-generated relativistic electron beam transport in solid or dense plasma targets, by Michaël J. Touati. It computes the two first angular moments of the relativistic Vlasov-Fokker-Planck-Belaiev-Budker kinetic equation completed with the Minerbo maximum angular entropy closure and coupled with target Magneto-Hydrodynamic equations considering time scales during which the return current has already set up.

fresco: scattering code for coupled-channels calculations, by I-Thompson. Frescox is an updated version.

libdlr: Fortran subroutines to build and work with the discrete Lehmann representation for single particle imaginary time Green’s functions, as well as the stand-alone Python module pydlr implementing the same functionality, by Jason Kaye and Hugo U.R. Strand

Linear Electromagnetic Oscillations in Plasmas with Arbitrary Rotationally-symmetric Distributions (LEOPARD): dispersion relation solver which can derive the frequencies and growth rates of electromagnetic waves with arbitrary propagation angle in homogeneous plasmas with an arbitrary number of particle species, by Patrick Astfalk. LEOPARD allows the computation of the (fully-kinetic) dielectric tensor components for both bi-Maxwellian or arbitrary gyrotropic velocity distributions. The implemented expressions for the dielectric tensor components are based on ‘Kinetic Theory of Plasma Waves’ by M. Brambilla (1998).

Quasilinear Electromagnetic Oscillations (QLEO): code based on the quasilinear kinetic equation which self-consistently describes how a given velocity distribution function of a homogeneous gyrotropic plasma evolves in time in the presence of an unstable spectrum of parallel propagating, electromagnetic linear eigenmodes, by Patrick Astfalk. The implemented formalism is based on the quasilinear kinetic equations given in, e.g., ‘Methods in Nonlinear Plasma Theory’ by R. C. Davidson (1972).

Quantum Chemistry and Electronic Structure

Abinitio DGA: implementation of a DGA approach for electronic structure calculations of materials, by Matthias Pickem. It allows the inclusion of non-local correlations beyond DMFT and the calculation of momentum-dependent susceptibilities.

bands4vasp: post processing package for the analysis of unfolded eigenstates in VASP, and much more: band structures, 2D and 3D Fermi surfaces, Fermi vectors and spectral functions, by David Dirnberger and Michele Reticcioli

ELectronic Structure Infrastructure (elsi): provides and enhances scalable, open-source software library solutions for electronic structure calculations in materials science, condensed matter physics, chemistry, and many other fields. ELSI focuses on methods that solve or circumvent eigenvalue problems in electronic structure theory. The ELSI infrastructure should also be useful for other challenging eigenvalue problems.

exciting: all-electron full-potential computer package for first-principles calculations, based on (linearized) augmented planewave + local orbital [(L)APW+lo] methods, by Stephan Sagmeister. This family of basis sets is known as the most precise numerical scheme to solve the Kohn-Sham equations of density-functional theory (DFT), reaching up to micro-Hartree precision.

NECI: implements the Full Configuration Interaction Quantum Monte Carlo (FCIQMC) algorithm, a method based on a stochastic application of the Hamiltonian matrix on a sparse sampling of the wave function. The program utilizes a very powerful parallelization and scales efficiently to more than 24 000 central processing unit cores.

omm-bundle: library implementing the orbital minimization method for solving the Kohn-Sham equation as a generalized eigenvalue problem, by Fabiano Corsetti et al.

soap_turbo: code associated with paper Miguel A. Caro. “Optimizing many-body atomic descriptors for enhanced computational performance of machine learning based interatomic potentials”. Phys. Rev. B 100, 024112 (2019).


Fortran-String-to-Real: converts strings to reals without using an internal read, by Carltoffel


Update since Nov. 13, full list here.


Automatic Line Fitting Algorithm (ALFA): identifies and fits hundreds of lines in emission line spectra in just a few seconds. It does this using a genetic algorithm to optimise the line parameters, by Roger Wesson

NEAT: calculates chemical abundances in photoionised nebulae, by Roger Wesson et al. It can propagate uncertainties and compensate for measurement biases affecting weak lines.

SMERCURY-T: upgrade of the SMERCURY orbital integrator that includes modules to enable the solar tidal spin torque as well as the general relativistic force, by Steven M. Kreyche


ARTEMIS-P: Anisotropic Ray Tracer for Electromagnetism in Magnetospheres, Ionospheres and Solar wind, including Polarisation, by Baptiste Cecconi and C. Baskevitch

Complete History of Interaction-Powered Supernovae (CHIPS): simulates the circumstellar matter and light curves of interaction-powered transients, by DTsuna et al. Coupling the MESA stellar evolution code and codes implemented by the authors, the user can obtain the circumstellar matter profile and light curves of the interaction-powered supernovae.

DAOPHOT-MCMC: modified version of the subroutine NSTAR.F which implements a Markov chain Monte Carlo (MCMC) routine for fitting highly blended stellar positions and fluxes, by Sean Terry. This code is installed and implemented within the overall DAOPHOT-II structure.

SpectralRadex: Python library for spectral modelling and RADEX, by Jon Holdship et al. SpectralRadex uses F2PY to compile a version of RADEX written in modern Fortran, most importantly dropping the use of common blocks. As a result, running a RADEX model creates no subprocesses and can be parallelized.


benchio: simple Fortran parallel IO benchmark for teaching and benchmarking purposes, by David Henty

Biology and Medicine

ECOSYS: code for terrestrial ecosystem biogeochemistry, by Robert Grant. A related project is EcoSim.

3D_Convolusional_Filtering: convolusional filtering of computed tomography scans, by JoGebert. Intended to get a clear separation between bone marrow and cancellous bone for subsequent binarization and calculations. Another project is Binarization and Domain Decomposition

Climate and Weather

convert_mpas: general conversion utility for MPAS-Atmosphere output files, by Michael Duda and David Ahijevych

ExoRT: reasonably flexible two-stream radiative transfer code designed for use with 3D climate models, by Eric T. Wolf. In this software, contained are builds for a 1-D offline version, and for directly interfacing with CESM/CAM4.

Himawari_HSD_Reader: reader for data from Japan’s Himawari satellite, by Simon Proud. This utility reads ‘raw’ HSD format data and can convert it into more friendly formats such as NetCDF4.

National Ocean Service Operational Forecast System from NCEP Central Operations (nosofs-NCO): copy from NOAA’s PMB website. This repository contains updates needed to run using GCC/GFortran compilers.

prodsim: collection of shell scripts and Fortran programs based on libsim, by Davide Cesari and ddales3. It is designed for processing raw numerical weather prediction (NWP) model output data and perform physically-based operations in order to obtain postprocessed data

shumlib: libraries which are used by the UM; the UK Met Office’s Unified Model, that may be of use to external tools or applications where identical functionality is desired. The hope of the project is to enable developers to quickly and easily access parts of the UM code that are commonly duplicated elsewhere.

simple atmospheric models: simple models of the atmosphere (and ocean), for classroom examples, by Mathew Barlow

Code Tools

Auto-Diff: implementation in Modern Fortran of backward mode automatic differentiation, by zoziha

Compiler Tests

test_compiler: tests the applicability of Fortran compilers in a project that develops optimization solvers, by Zhang Zaikun

Computational Chemistry

Aerosol Inorganic-Organic Mixtures Functional groups Activity Coefficients (AIOMFAC): thermodynamic group-contribution model to describe non-ideal mixing in liquid solutions

chemfiles.f03: Fortran 2003 binding to the chemfiles library, by Guillaume Fraux et al.

ClassyMC: General Purpose Object Oriented Molecular Monte Carlo code. Classy is designed to be used for Metropolis Monte Carlo and other similar sampling methods in molecular simulations.

Python-Fortran-Fluids (PyForFluids): Python package focused in the calculation of Fluid properties based on Equations of State (EoS), by Federico E. Benelli et al. It provides a simple interface to work from Python but also exploits the high performance Fortran code for the more heavy calculations.

structure analysis on the command line (struca): simple tool to help compare structures and compute trajectory data on the command line, by Holger Kruse

Computational Fluid Dynamics

2DEulerSolver: numerically solve the Euler equations over a channel with a bump using Jameson scheme finite volume analysis, by FrostyNip

CFD Utility Software Library (CFDTOOLS): contains nearly 30 numerical analysis libraries and close to 100 utility applications built upon those libraries. These utilities were developed over a rougly fifty year span to support aerospace research and development activities at NASA Ames Research Center (ARC).

euler2D-kfvs-Fortran2003: compressible Euler equations solver using kinetic flux vector splitting (KFVS) scheme, by truongd8593

Fluid2d: versatile Python-Fortran CFD code that solves a large class of 2D flows, by Guillaume Roullet et al. It is designed to be used easily by Students learning Fluid Mechanics or Geophysical Fluid Dynamics and by their professors willing to illustrate their course and to organize numerical practicals.

IMEXLB-1.0: Lattice Boltzmann Method (LBM) proxy application code-suite for heterogeneous platforms (such as ThetaGPU). A ProxyApp, by definition, is a proxy for a full-fledged application code that simulates a wider array of problems.

interpolate-fields: interpolates DNS data to a new grid using linear interpolation, by Pedro Costa. It can run and store the interpolated data in a massively-parallel setting using MPI I/O. For now, it assumes two regular Cartesian grids with the file format of CaNS.

MGLC: multi-GPU parallel implementation of LBM(Lattice Boltzmann Method), using OpenACC to accelerate codes on single GPU and MPI for inter-GPU communication

Multi-component Flow Code (MFC): parallel simulation software for multi-component, multi-phase, and bubbly flows, by Spencer Bryngelson et al.

NekIBM: implementation of Immersed Boundary Method for for exascale simulation of multiphase flow based on the Spectral Element Method Nek5000/CMTnek code, by Yunchao Yang

NGA2: high performance computing research library that provides a variety of finite volumes/finite difference solvers for typical fluid-related partial differential equations, by Olivier Desjardins and Austin Han

Non-HydrostaticWave Model (NHWAVE): three-dimensional shock-capturing model which solves the incompressible Navier-Stokes equations in terrain and surface-following sigma coordinates. The model predicts instantaneous surface elevation and 3D flow field and is capable of resolving coastal wave processes (shoaling, refraction, diffraction, breaking etc.) as well as tsunami wave generation by landslide.

Earth Science

celltrack: finds continuous cells in 2D fields and tracks them in time. The primary use case is rain cell tracking. Related paper: Lochbihler, K., Lenderink, G., and Siebesma, A. P. (2017), The spatial extent of rainfall events and its relation to precipitation scaling, Geophys. Res. Lett., 44, 8629– 8636, doi:10.1002/2017GL074857.

GOCART: aerosol model including process library and framework interfaces (MAPL, NUOPC, and CCPP), from Goddard Earth Observing System - Earth System Modeling

MANDIFORE_modeling: Forestry x climate scenarios for NSF-funded MANDIFORE project, by Christy Rollinson and Lucien Fitzpatrick

NM-CT: Fortran and Matlab codes for the paper “A Chebyshev-Tau spectral method for normal modes of underwater sound propagation with a layered marine environment”, by H. Tu, Y. Wang, Q. Lan et al.

PyRaysum:g enerates sets of ray-theoretical seismograms for an incident plane wave (teleseismic approximation) for models consisting of a stack of layers with planar but nonparallel (dipping) interfaces, allowing the possibility of anisotropy in the layers. Incident P and S waves are supported.

PyRaysum is a Python wrapper around the Fortran software Raysum, originally developed by Andrew Frederiksen.

Tracmass: Lagrangian trajectory code for ocean and atmospheric general circulation models, by Aitor Aldama and Kristofer Döös. The code makes it possible to estimate water paths, Lagrangian stream functions (barotropic, overturning, etc.), exchange times, etc.

Wetland Water Quality Model (WetQual-GUI): simulates nitrogen (N), phosphorus (P), total suspended sediment (TSS) and carbon (C) cycles and their dynamics in wetlands, by Daniel Lee Young et al. The model partitions a wetland into three basic compartments: (1) (free) water column, (2) wetland soil layer, which is further portioned into aerobic and anaerobic zones, and (3) plant biomass.

yelmo: 3D ice-sheet-shelf model solving for the coupled dynamics and thermodynamics of the ice sheet system. Yelmo can be used for idealized simulations, stand-alone ice sheet simulations and fully coupled ice-sheet and climate simulations.


trendInflation: code for trend inflation model of Mertens (2016, REStat, Measuring the Level and Uncertainty of Trend Inflation | The Review of Economics and Statistics | MIT Press) and Garnier, Mertens and Nelson (2015, IJCB, Trend Inflation in Advanced Economies). The model implemented here is the variant with stochastic volatility in all inflation gaps.

File I/O

Convert Precision: converts large binary files in parallel from/to single to/from double precision, using MPI-I/O, Pedro Costa. The code assumes that the each file contains only single- or double-precision floating-point.

hdf5_wrapper: Fortran wrapper for HDF5 (.h5 files), by Christian Bustamente. It provides a simpler interface that allows easy writing and reading of h5 files for double precision and integer arrays of up to six dimensions. On top of the Fortran wrapper, the package provides a Matlab function that simplifies the process of reading entire h5 files.

json-fortran: KISS Fortran routines to write (multi-dimensional) data as JSON, by Jonathan Schilling

neasy-f: simple wrapper for netCDF-Fortran, from PlasmaFAIR. Rather than attempting to be a feature-complete replacement, neasy-f wraps some common functions together and is opinionated about usage.


life: Conway’s game of life, by Jeff Irwin

rubik: Rubik’s cube command line interface game, by Jeff Irwin

General Purpose

Auto-generated time-stamped folder: code for auto generating a time-stamped folder, log file, and data file (csv) to store results of each run of the code, by Mohammad Asif Zaman. The submodules can be easily incorporated in any program. Useful for cases when the same program must be run many times and the corresponding data must be saved in files.

flist: modern Fortran linked lists using unlimited polymorphic derived types, by Jacob Williams

Fortran pathlib: Filesystem path manipulation utilities for standard Fortran, from scivision. Inspired by Python pathlib and C++17 filesystem.

fuuid4: generates random (version 4) Universally Unique Identifiers (UUIDs). Fuuid4 can either wrap the libuuid generator, or use the bundled Mersenne Twister psuedo-random number generator (PRNG) to generate UUIDs itself.

M_msg: convert all common variables to a string in Fortran using unlimited polymorphic variables, by urbanjost.

M_stopwatch: package for measuring cpu and wall clock execution time by urbanjost, based on StopWatch. It supports the wall clock, CPU clock, and a breakdown of the CPU clock into user and system times.

progressbar: simple C library for drawing a progress bar on a memory mapped log file, designed to introduce as little overhead as possible, by G-Lorenz and giambagiamba. It is compatible with C++ and Fortran.

Graphics, Plotting, and User Interfaces

PlPlotLib: wrapper for PlPlot inspired by the interface of matplotlib, by zoziha. It is intended to fill the need for rapid feedback while developing numerical simulations, and does not replace more sophisticated packages such as matplotlib or even direct use of PlPlot.

PyFerret: Ferret is an interactive computer visualization and analysis environment designed to meet the needs of oceanographers and meteorologists analyzing large and complex gridded data sets, from NOAA/PMEL. It runs on recent Unix and Mac systems, using X windows for display. PyFerret, introduced in 2012, is a Python module wrapping Ferret.

pnmio: I/O routines for portable anymap image files (.pbm, .pgm, .ppm), by Jeff Irwin. Currently only output routines are provided.


Advanced Options and Tables in Universal Scripting (AOTUS): wrapper around the C-API of the Lua scripting language, allowing a convenient usage of Lua scripts as configuration files in Fortran applications.

Linear Algebra

LSQR: Fortran 2008 edition of LSQR, a conjugate-gradient type method for solving sparse linear equations and sparse least-squares problems, by Jacob Williams.

Minimum Split Checkerboard Decomposition (MSCBDECOMP): obtain sparse representations of the matrix exponential, by CaptainSifffl. Reference: Minimal Split Checkerboard Method for Exponentiating Sparse Matrices and Its Applications in Quantum Statistical Mechanics, by Che-Rung Lee, SIAM J. Sci. Comput. 35-2 (2013), pp. C143-C171

ScalapackFx: modern Fortran 2003 wrappers for the routines of the ScaLAPACK library, by Ben Hourahine et al. Currently mostly the routines related to diagonalization are covered.

TensorTools: modern Fortran library for tensor calculus, by Lukas Lamm

Materials Science

mef90: reference implementation of the variational approach to fracture, as described in several papers, by Blaise Bourdin

Nonlinear MetaMaterial MPI Solver (NM^3): codes and example files used in paper, “High-Performance Large-Scale Simulation of Multi-stable Metastructures”, by M. Hwang, C. Scalo, and A. F. Arrieta, to be published.

Polymer Self-Consistent Field Theory (PSCF): numerically solves the polymer self-consistent field theory (SCFT) for spatially periodic structures formed by block copolymer melts and mixtures of block copolymers with linear homopolymers and/or small molecule solvents, by David Morse et al.

sulfur-magma: predicts of sulfur redox state in magmatic liquids, by Roberto Moretti and Charles Le Losq. Associated paper: Moretti, R., & Ottonello, G. (2003). A polymeric approach to the sulfide capacity of silicate slags and melts. Metallurgical and Materials Transactions B, 34(4), 399–410.

usrmat_LS-Dyna_Fortran: basics to implement user-defined materials (usrmat, umat, utan) in LS-Dyna with Fortran, by jfriedlein

Mesh Generation

High Order Hex-Quad Mesh (HOHQMesh): generates all-quadrilateral meshes with high-order boundary information, by David A. Kopriva et al.

Molecular Dynamics

dl-poly: general-purpose classical molecular dynamics (MD) simulation software developed at Daresbury Laboratory since 1992. Over the years has been transformed from a replicated memory code to a distributed memory one.

examples from “Computer Simulation of Liquids”: code by Michael P. Allen and Dominic J. Tildesley to accompany book. The programs contain some explanatory comments, and are written, in the main, in Fortran 2003/2008.

Neural Networks and Machine Learning

Fortran-Torch-Adapter: integrates a deep learning model into a Fortran environment, by luc99hen

MlFortran: library designed for the writing and the development of Complex System models, by Etienne Descamps. It is written in a modern object-oriented Fortran 2008 and has a C and C++ interface. Its aim is to ease the development of complex models in lower level language such as C/C++ and Fortran by providing structures and algorithms that can be found in higher level programming language such as Matlab or Python/SciPy.

pytorch-fortran: provides Fortran HPC codes with a simple way to use Pytorch deep learning framework, so that Fortran developers can take advantage of rich and optimized Torch ecosystem from within their existing codes.


Naval Surface Warfare Center (NSWC) Mathematical Library: collection of Fortran 77 routines specializing in numerical mathematics. Subroutines are available in the following areas: elementary operations, geometry, special functions, polynomials, vectors, matrices, large dense systems of linear equations, banded matrices, sparse matrices, eigenvalues and eigenvectors, L1 solution of linear equations, least-squares solution of linear equations, optimization, transforms, approximation of functions, curve fitting, surface fitting, manifold fitting, numerical integration, integral equations, ordinary differential equations, partial differential equations, and random number generation.

Nonlinear Equation Solver with Modern Fortran (nlesolver-fortran): basic Newton-Raphson type nonlinear equation solver for dense systems with m functions of n input variables, by Jacob Williams. Uses LAPACK routines (dgesv or dgels) to solve the linear system.


fmin: derivative-free 1D function minimizer in modern Fortran, by Jacob Williams

Particle Swarm Optimization (PSO) code in Fortran 95: general code that can be used with any fitness function, by Mohammad Asif Zaman

Parallel Programming

f77_zmq: Fortran 77 binding library for ZeroMQ, an open-source universal messaging library, by Anthony Scemama et al.

galaxy-brain: MPI Fortran type inference, by Jeff Hammond

GPU programming with OpenMP offloading: exercises and other material for course, by Jussi Enkovaara et al.

rpncomm: MPI-based communication routines for models, by mfvalin

Partial Differential Equations

Numerical Analysis Problems and Solutions: codes to solve boundary value problems and the time-dependent (time-independent) heat equation over a one dimensional region, by Pavel Kureichyk

pigasus: generic Python package for solving (system of) Partial Differential Equations, by Ahmed Ratnani. Its core is written in Fortran. The aim of Pigasus is to discretize spatial differential operators, which makes it easier to write different time schemes thanks to the oriented object aspect of Python.

Sequential Software for the Robust Multigrid Technique: code associated with book by S. I. Martynenko. Presents basic concepts of modern numerical methods for mathematical modeling of physical and chemical processes in the computational continuum mechanics (thermal conductivity, chemical hydrodynamics, convective heat transfer, electrodynamics, etc.). Robust_Multigrid_Technique_2021_OpenMP is an OpenMP version.

Particle Physics

Cyclone: cyclotron orbit code by Bruce F. Milton. It calculates orbits using both magnetic and electric field maps and is therefore useful for central region design.

dmfortfactor: program for experimental WIMP analysis that computes the differential event rate per recoil energy for WIMP-nucleon scattering events, by Calvin Johnson and Oliver Gorton

GEometry ANd Tracking (geant3): simulation software using Monte Carlo methods to describe how particles pass through matter, by Ivana Hrivnacova et al.


aorsa3d: solves for the wave electric field and heating in a 3-D stellerator plasma heated by radio frequency waves using an all orders spectral algorithm, by Naoto Tsujii and David L. Green

Dr. Probe command-line tools (drprobe_clt): CELSLC is a program to calculate object transmission functions to be used as phase gratings in a multislice algorithm for electron diffraction calculations. MSA is a program to calculate the diffraction of beam of probing electrons through a crystal. MSA is a program to calculate the diffraction of beam of probing electrons through a crystal.

MagTense: magnetostatic and a micromagnetism calculation framework, in Fortran with Matlab MEX and Python interfaces, by Kaspar Kirstein Nielsen et al.

SCENE: tokamak equilibrium solver which can generate equilibria in a variety of file formats, from PlasmaFAIR

Spherical-Coordinate Implicit Derivatives time-dependent Schroedinger equation (SCID-TDSE): numerical solution of TDSE for a one-electron atom subject to a laser field, by Serguei Patchkovskii. TDSE is solved in spherical coordinates, with the laser field treated in the velocity-gauge dipole approximation.

stella: solves the gyrokinetic-Poisson system of equations in the local limit using an operator-split, implicit-explicit numerical scheme, by Denis St-Onge et al. It is capable of evolving electrostatic fluctuations with fully kinetic electrons and an arbitrary number of ion species in general magnetic geometry, including stellarators.

T-matrix for Electromagnetic Radiation with Multiple Scatterers (TERMS): simulates the near-field and far-field optical properties of collections of particles, by Dmitri Schebarchov et al. TERMS solves rigorously the Maxwell equations via the superposition T-matrix method, where incident and scattered fields are decomposed into a basis of multipolar electric and magnetic spherical waves.

Quantum Chemistry and Electronic Structure

eXternal OPTimizer for quantum chemistry (XOPT): robust optimizer for quantum chemical and semi-empirical method that is suitable for large and complex molecules, by Holger Kruse

ffr-PWDFT: poor man’s program in simple Fortran 90 to carry out electronic structure calculations based on plane wave basis set and pseudopotential, by Fadjar Fathurrahman

ffr-LFDFT: solves electronic structure problems based on density functional theory (DFT) and Kohn-Sham equations using Lagrange basis functions, by Fadjar Fathurrahman

Molecular Orbital PACkage (MOPAC): general-purpose semiempirical molecular orbital package for the study of solid state and molecular structures and reactions. The semiempirical Hamiltonians MNDO, AM1, PM3, PM6, RM1, MNDO-d, and PM7 are used in the electronic part of the calculation to obtain molecular orbitals, the heat of formation and its derivative with respect to molecular geometry.

periodic-NBO: This projection code is capable of representing any plane-wave bands output by VASP into any user specified Gaussian type orbital basis set. Such an AO representation is required for the subsequent NBO analysis. The code is set up to then output all information necessary for periodic NBO analysis using the code of JRS and BDD.

Plane Wave Density Functional Theory (PWDFT): PW-DFT development for NWChemEx, by Eric Bylaska et al.

ShirleyForQE: distribution of the Quantum ESPRESSO suite of codes (ESPRESSO: opEn-Source Package for Research in Electronic Structure, Simulation, and Optimization).

SkProgs: generates Slater-Koster files for the Density Functional Based Tight Binding method (DFTB-method), by Bálint Aradi et al.

soap_turbo: code associated with paper Miguel A. Caro. “Optimizing many-body atomic descriptors for enhanced computational performance of machine learning based interatomic potentials”. Phys. Rev. B 100, 024112 (2019).

WFNSYM: calculates continuous symmetry measures (CSM) of the electronic wave function of molecules, by Abel Carreras and ‪Efrem Bernuz

Random Number Generation

FortRAND: lightweight random sampling library written in modern Fortran, by Lukas Lamm. It provides a simple interface to the build in Fortran pseudo-random number generator for the generation of uniformly distributed random numbers. In addition, it also provides algorithms for sampling numbers from various other distributions.

Reactor Physics

MISA-SCD: parallel stochastic cluster dynamics simulation software for reactor structural material, by Chendandan


M_sort: collection of Fortran procedures that do simple sorts, by urbanjost


Bayesian Inference for Factor Modeling (BayesFM): R package with a collection of procedures to perform Bayesian analysis on a variety of factor models, calling Fortran 2003 code, by Rémi Piatek. It includes random number generators for uniform and non-uniform distributions.

em-fortranbox: econometrics modules by Elmar Mertens

Optimal Subset CArdinality Regression models (oscar): R package with underlying Fortran code by T. D. Laajala

pygslib: GSLIB (Geostatistical Software LIBrary) Fortran code wrapped into python


fortran-pcre2: Fortran 2018 ISO_C_BINDING interfaces to Perl-compatible Regular Expressions 2 (PCRE2), by interkosmos

Time Series

KFAS: R Package for Exponential Family State Space Models: provides tools for modelling exponential family state space models such as structural time series, ARIMA models, generalized linear models and generalized linear mixed models, by Jouni Helske et al., with underlying Fortran 95 code

signal_subspace: 1-D and ensemble signal subspace analysis with methods such as Esprit and RootMusic in Fortran, C, and Python, from scivision, based in part upon the Spectral Analysis Lib public domain code. The core subspace code is written in Fortran 2008 and is called from other languages (Python, C).

Time Series Analysis with State Space Model (TSSS): R package with underlying Fortran code, used in the book Introduction to Time Series Modeling with Applications in R, 2nd ed., by Genshiro Kitagawa

1 Like

This is really a great post. Can this list of new Fortran projects be added to the Fortran lang website?

What is the criterion for the distinction between Astronomy and Astrophysics? My impression is that is totally arbitrary and random. ALFA and SpectralRadex are both spectral line analysis and got added to different categories. I’d vote for making just one Astronomy category.

Great list! If you’re interested, I have a Fortran error handling framework which you’re welcome to add: GitHub - samharrison7/fortran-error-handler: Comprehensive error framework for applications requiring functional and robust error handling, utilising the power of modern object-oriented Fortran.

It’s on my to-do list to make it fpm compatible, but it’s not yet I’m afraid.


It has been a bit arbitrary. Sometimes I have looked at the words used in the project description and the name of the journal in which an associated paper was published. I will combine the categories unless someone thinks a meaningful distinction can be made.

Update since Dec. 13, 2021, full list here. The astronomy and astrophysics sections have been combined, as suggested.

Astronomy and Astrophysics

DUMSES-hybrid: 3D MPI/OpenMP & MPI/OpenACC Eulerian second-order Godunov (magneto)hydrodynamic simulation code in cartesian, spherical and cylindrical coordinates, by Marc Joos

OrbFit: this version of the OrbFit package, by Marco Fenucci, contains a modified version of the orbit9 integrator. The integrator has been modified to integrate the spin axis dynamics of small asteroids, due to the Yarkovsky–O’Keefe–Radzievskii–Paddack (YORP) effect.

Optab: computes opacity based on user-provided chemical equilibrium abundances, and outputs mean opacities as well as monochromatic opacities, by Shigenobu Hirose. Consequently, one can have opacity tables consistent with one’s equation of state.

POT3D: High Performance Potential Field Solver: computes potential field solutions to approximate the solar coronal magnetic field using observed photospheric magnetic fields as a boundary condition. A version of POT3D that includes GPU-acceleration with both MPI+OpenACC and MPI+OpenMP was released as part of the Standard Performance Evaluation Corporation’s (SPEC) beta version of the SPEChpc™ 2021 benchmark suites.


pi_examples: calculate pi using numerical integration of 1/(1+x**2), using Fortran with do concurrent, MPI, OpenMP, OpenACC, and other languages, by Owain Kenway et al.

Biology and Medicine

Euplectella_HPC: code for paper Extreme flow simulations reveal skeletal adaptations of deep-sea sponges, by Giacomo Falcucci et al., Nature volume 595, pp 537–541 (2021)

Climate and Weather

Global Environmental Multiscale Model (GEM): integrated forecasting and data assimilation system developed by the Atmospheric Numerical Prediction Research Section, Meteorological Research Division, of Environment and Climate Change Canada.

Noah-OWP-Modular: extended, refactored version of the Noah-MP land surface model, by K. Jennings et al. In order to ease readability, adaptability, and interoperability, the model has been broken out into a series of modules and data types that represent various components of model information and parameters as well as the energy and water balances.

NCEPLIBS G2: Utilities for coding/decoding GRIB2 messages, by Hang Lei et al. This library contains Fortran 90 decoder/encoder routines for GRIB edition 2, as well as indexing/searching utility routines.

Computational Chemistry

QCxMS: quantum chemical (QC) based program that enables users to calculate mass spectra (MS) using Born-Oppenheimer Molecular Dynamics (MD), by Jeroen Koopman and Sebastian Ehlert. It is the successor of the QCEIMS program, in which the EI part is exchanged to x (x=EI, CID) to account for the greater general applicability of the program. Plot Mass Spectra (PlotMS) is an associated plotting program.

Computational Fluid Dynamics

EPIC: Elliptical Parcel-in-Cell model for fluid dynamics, by Matt Frey

LBcuda: CUDA Fortran code to solve Lattice Boltzmann equations of a multi-component flow interacting with rigid spherical particles, by Fabio Bonaccorso et al.

ParaTC: high order finite difference solver for simulations of turbidity currents with high parallel efficiency, by Zheng Gong

Smoothed Particle Hydrodynamics(SPH): uses code from the book Smooth Particle hydrodynamics - A Meshfree Particle Method as a starting point, by zoziha

Xoptfoil: airfoil optimization code using the Xfoil aerodynamics engine, by montagdude and Geoff Sokoll

Earth Science

ECCOv4-Configurations: documentation and model configuration files for official releases of the ECCO version 4 ocean and sea-ice state estimates, by Ou Wang et al. Model configuration files allow users to reproduce the state estimate or conduct new simulation experiments.

Finite Element Heat and Mass Transfer Code: FEHM: simulates groundwater and contaminant flow and transport in deep and shallow, fractured and un-fractured porous media throughout the US DOE complex. FEHM has been used in projects of national interest including Environmental Remediation of the Nevada Test Site, the LANL Groundwater Protection Program, geologic CO2 sequestration, Enhanced Geothermal Energy (EGS) programs, Oil and Gas production, Nuclear Waste Isolation, and Arctic Permafrost.

Heavy: calculates the change in gravity caused by the change in groundwater storage as predicted by a MODFLOW groundwater-flow model, by Jeff Kennedy. Gravity change is calculated relative to the initial time step at user-specified locations (e.g., measurement locations).

NanoFASE: multimedia spatiotemporal model of nanomaterial fate, speciation and bio-uptake, by Sam Harrison and slofts

Passive and Active Microwave TRANsfer (PAMTRA): Python/Fortran 90 package to solve the passive and active microwave radiative transfer in a plan parallel horizontally homogeneous atmosphere with hydrometeors, by Davide Ori et al.

SWMM5 +: prototype Fortran 2008 engine for the EPA Storm Water Management Model (SWMM), by Gerardo Andrés Riaño Briceño et al.

File I/O

h5fortran-mpi: HDF5-MPI parallel Fortran object-oriented interface, from scivision

Fortran Books and Tutorials

FortranTip: short instructional Fortran codes associated with Twitter @FortranTip, by Beliavsky et al.

General Purpose

Fortran Error Handler: universal and comprehensive solution for applications requiring functional and robust error handling, utilising the power of modern object-oriented Fortran, by Sam Harrison and KellerV

M_kracken95: Fortran 95 version of the kracken(3f) procedure (and related routines) for command line parsing, by urbanjost

M_readline: interface to the commonly available C procedure readline(3c). to provide a familiar command history interface for interactive programs, by urbanjost

paramcard: command-line parameter input made simple, by Takahiro Ueda

Graphics, Plotting, and User Interfaces

graffer: interactive tool for generating plots of data and/or functions, by James Tappin. The original graffer was an IDL program. This version provides most of the same functionality in a Fortran program using gtk-fortran and plplot for the GUI and plotting respectively. To display functions gdl (gnudatalanguage) or IDL is required.

M_pixel: creates pixel images with a vector-oriented graphics library that emulates a subset of the M_draw vector graphics library, by urbanjost. It is supplemented with additional modules that read and write GIF files, including animated GIFs.


fortran-cython-examples: examples for how to wrap Fortran with Cython, by Nick Wogan

Fortran Unsigned Wrapper (funsignedwrapper): module with functions for accessing unsigned variables in standard Fortran 2008, by Johann Andreas Weber

Linear Algebra

SParse matrices in Object-Oriented Fortran (SPOOF): modern, object-oriented Fortran library for sparse matrix computations, by Sam Harrison. It largely draws on the SPARSKIT library, adding an object-oriented interface to improve usability.

Materials Science

LBsoft: software for soft glassy emulsion simulations, by Fabio Bonaccorso et al.

Molecular Dynamics

Reactive_PB_NN_MD: reactive molecular dynamics code based on PB-NN potentials, in which neural networks are utilized in the off-diagonal elements of the Hamiltonian to mediate the chemical reactions, by Sam Delmerico et al. This code uses a custom update algorithm to calculate PME forces for the diabatic states in the Hamiltonian matrix.

Structure_factor_FFT: computes structure factors using the particle mesh Ewald approach, by Jesse Gatten McDaniel. Either the electron density structure factor can be computed for X-ray scattering (uses form factors), or the total charge density can be computed (uses input force field charges) to evaluate sum rules


Bessel-Hankel: examples of the Hankel transformation and calculations of Bessel functions of the 1st kind and 2nd kind, their derivatives of the 1st order and 2nd order, and their zeros, by Tche Liu

MPFUN2020: thread-safe arbitrary precision package that enables one to perform floating-point computations (real and complex) to arbitrarily high numeric precision, by making only relatively minor changes to existing Fortran-90 programs (mostly changes to type statements), by David H. Bailey. All basic arithmetic operations and transcendental functions are supported, together with several special functions.

ToolboxFortran: code to replicate basic Matlab functions, sort, interpolate, optimize, find roots, and perform other numerical tasks, by Alessandro Di Nola. Also code to read and write multidimensional arrays.

Numerical Integration (Quadrature)

kronrod: generates Gauss-Kronrod coefficients, by Jacob Williams

Quadpack2: update by Jacob Williams and Sebastian Ehlert of QUADPACK, a FORTRAN subroutine package for the numerical computation of definite one-dimensional integrals

Ordinary Differential Equations

rkf45: Fehlberg fourth-fifth order Runge-Kutta method, adapted by zoziha from the code at Netlib

Parallel Programming

CoArray Fortran Framework of Efficient Interfaces to Network Environments (Caffeine): parallel runtime library that aims to support Fortran compilers with a programming-model-agnostic application binary interface (ABI) to various communication libraries, by Damian Rouson et al. Current work is on supporting the ABI with the GASNet-EX or with POSIX processes.

Tensor Algebra Library Routines for Shared Memory Systems: Nodes equipped with multicore CPU, NVIDIA GPU, AMD GPU, and Intel Xeon Phi (TAL_SH): implements basic tensor algebra operations with interfaces to C, C++11, and Fortran 90+, by Dmitry I. Lyakh

Particle Physics

APFEL: A Parton Distribution Function Evolution Library: performs DGLAP evolution up to NNLO in QCD and to NLO in QED, both with pole and MSbar masses. The coupled DGLAP QCD+QED evolution equations are solved in x-space by means of higher order interpolations and Runge-Kutta techniques.

remoll: simulations for the MOLLER Experiment at Jefferson Lab, which proposes to measure the parity-violating asymmetry in electron-electron (Møller) scattering


DASH: versatile and interactive package for solving crystal structures from powder diffraction data, by Jason Christopher Cole et al. DASH solves structures by simulated annealing of structural models to indexed diffraction data and features a helpful wizard to guide the user through the entire structure solution process.

Phase Monte Carlo radiation transport (pMC): code by Lewis McMillan for paper Imaging in thick samples, a phased Monte Carlo radiation transfer algorithm

Physical optics propagation through synchrotron radiation beamlines (PHASE): tool for the optical design of synchrotron radiation beamlines, by Uwe Flechsig. It is based on analytic expressions for nonlinear transformation of beam coordinates across optical elements. Documented here

signedMCRT: use of signed distance fields in Monte Carlo Radiative Transfer, by Lewis McMillan. This allows modelling of smooth surfaces without the need to use triangle or similar meshes.

Quantum Chemistry and Electronic Structure

A Fortran Electronic Structure Programme (AFESP): project based on the Crawford Group’s C++ Programming Tutorial in Chemistry, but written in Fortran, by Kirk Pearce et al. The end goal of this project will be performing HF, MP2, CCSD, and CCSD(T), as per the original tutorial, but with additional support for multicore processors (modern CPUs, GPUs).

EDIpack: Lanczos-based solver for generic quantum impurity models exploiting distributed memory MPI parallelisation, from QcmPlab. Related is EDlattice, a parallel Exact Diagonalization algorithm for interacting electrons on a lattice.

fold2Bloch: unfolding of first-principle electronic band structure obtained with WIEN2k DFT-(L)APW code, by Anton Bokhanchuk et al.

peacemaker: quantum cluster equilibrium theory for applying statistical mechanics to quantum-chemically optimized clusters, forked by Sebastian Ehlert

qe-gpu: GPU-accelerated Quantum ESPRESSO using CUDA Fortran, by Filippo Spiga

Random Number Generation

fortran-splitmix64: splitmix64 RNG in Fortran 2008, by DSCF-1224

xoshiro-fortran: implementation of xoshiro/xoroshiro in Fortran 2008, by DSCF-1224

Reactor Physics

PREPRO 2021: collection of 18 module codes which are designed to convert ENDF/B formatted evaluated data from the originally distributed ENDF-6 format to formats in which the data can be used in application codes, by Georg Schnabel et al.


Multi-Reader Multi-Case Analysis of Variance: MRMCaov: R package with underlying Fortran code for statistical comparison of diagnostic tests - such as those based on medical imaging - for which ratings have been obtained from multiple readers and on multiple cases, by Brian J. Smith


Fregex: Perl Compatible Regular Expressions (PCRE) wrapper for Fortran by Ian Giestas Pauli

Time Series

wavepack: computes the wavelet transform of a time series, and significance levels, by zoziha

Unit Testing

Fortran Unit Test Framework (FortUTF): unit test framework written purely in Fortran to be compatible with as many projects as possible, by Kristian Zarębski

test-drive: lightweight, procedural unit testing framework based on nothing but standard Fortran, by Sebastian Ehlert and Jeremie Vandenplas. Integration with meson, cmake and Fortran package manager (fpm) is available.


Update since Jan. 15 2022, full list here. A project may be years old but newly added to the list.

Astronomy and Astrophysics

astro-fortran: modern Fortran implementations of standard models used in fundamental astronomy, by Jacob Williams. It is a refactoring of IAU SOFA.

dStar: computing neutron star structure and evolution, by Edward Brown et al.


Bandwidth Benchmark (Fortran version): collection of simple streaming kernels for teaching purposes, from RRZE-HPC. It is heavily inspired by John McCalpin’s STREAM.

Compiler-benchmark-suites: list of benchmark suites (and some loose kernels) in C and Fortran used in the research related to compilers, program performance, scientific computations etc.

Julia Syntax: Comparison with Fortran: simple cheatsheet and some performance comparison for scientific programmers who are interested in discover Julia, by Pierre Navaro

Biology and Medicine

EpiDetector: identifies epistasis (i.e., gene-to-gene interactions) in a genome-wide analysis setting, by Jakub Pecanka. EpiDetector implements several flavors of a two-stage testing approach. The underlying methodology is described in this paper and book chapter.

Code Tools

adjac: automatic differentiation for generating sparse Jacobians, using Fortran 95 and operator overloading, by Pauli Virtanen

fazang: library for reverse-mode automatic differentiation, inspired by Stan/Math library, by Yi Zhang

Fortran Debug Utilities: collection of some utilities useful for debugging code, by Pål Levold

Computational Chemistry

Kinetic Monte Carlo of Systems (kmcos): lattice based kinetic Monte Carlo with a Python front-end and Fortran back-end, by Max Hoffmann et al.

MobCal-MPI: parallelization of the commonly used MobCal suite to calculate ion mobilities and collision cross sections, by Christian Ieritano and Scott Hopkins

mstore: molecular structure store for testing, from grimme-lab

Containers and Generic Programming

fdict: native Fortran 90 dictionary with hash tables for retaining any data-type in a Python-like dictionary, by Nick Papior

FMacro: template preprocessor for Fortran, by Harris Snyder. Aims to address Fortran’s lack of support for generic programming with a simple preprocessor, modeled after some of the language committee’s early ideas for a template language feature, to be included in a future Fortran standard.

Fortran Implementation of Abstract Types (FIAT): aims to implement various common data structures in Fortran, by Chris MacMackin and gitter-badger. These will be implemented in a generic manner using a container type. This was originally developed in PolyCon but has since been folded into FIAT, with some improvements.

Fortran Preprocessor Templates for Dynamic Data Structures (FPT-DDS): implements Fortran templates to create dynamic data structures using preprocessor directives, by Sergio Alexis Paz. A data structure for an arbitrary data type can be easily constructed by defining a few preprocessor variables and including the corresponding files distributed in the include folder.

Fortran Template Library (FTL): generic containers, versatile algorithms, easy string manipulation, and more, by Robert Rüger and Tomáš Trnka. It is heavily inspired by C++'s standard library, especially the part that is commonly referred to as the Standard Template Library (STL).

Fortran Template Library (FTL): object-oriented implementation of generic containers similar to the C++ STL (Standard Template Library), by Fran Martinez Fadrique. Not all elements present in STL are implemented in FTL, yet the documentation in Containers - C++ Reference can be used as generic conceptual reference.

FTObjectLibrary: provides a collection of reference counted Fortran 2003 classes to facilitate writing generic object oriented Fortran programs, by David A. Kopriva et al.

qContainers: container library for Fortran language. It enables one to store any internal Fortran data type and any derived data type to the container. It implements containers for key/value pairs: tree table and hash table, and containers for objects: list and vector.

Computational Fluid Dynamics

Turbulent Flows (T-Flows): computational fluid dynamics program originally developed at Delft University of Technology, the Netherlands. It features second order accurate, unstructured, cell-centered, finite volume discretization of incompressible Navier-Stokes equations with heat transfer and species transport. It is written in Fortran 90 and uses Message Passing Interface (MPI) for parallel execution.

Earth Science

CLM-Microbe: modeling work within the Ecological Modeling and Integration Laboratory at SDSU. One publication is Substrate and environmental controls on microbial assimilation of soil organic carbon: a framework for Earth system models.

Coupled Water Balance and Vegetation Optimality Model (VOM): predicts vegetation water use based on meteorological information, soils and topography only, without the need for prescribing site-specific vegetation properties or calibration against observed fluxes, by Stan Schymanski et al.

Dynamically Simple Model of Atmospheric Chemical Complexity (DSMACC): tropospheric chemistry box model designed to help understand the composition of the troposphere in a flexible and friendly manner. It is written to address a range of problems ranging from calculating the expected concentrations of atmospheric radicals to comparing chemistry schemes.

Earth System Modeling Framework (ESMF): suite of software tools for developing high-performance, multi-component Earth science modeling applications, by Gerhard Theurich et al.

EddyPro: processes eddy covariance data, by LI‑COR Biosciences. It computes fluxes of water vapor (evapotranspiration), carbon dioxide, methane, other trace gases, and energy with the Eddy Covariance method.

GSFLOW: coupled Groundwater and Surface-water FLOW model based on the integration of the USGS Precipitation-Runoff Modeling System (PRMS-V) and the USGS Modular Groundwater Flow Model (MODFLOW-2005 and MODFLOW-NWT), by Steve Regan et al.

JAGURS: tsunami simulation code solving linear/nonlinear long-wave/Boussinesq equations with/without effects of elastic deformation of the Earth due to tsunami load and vertical profile of seawater density stratification. This code was parallelized by using OpenMP and MPI.

MCDisp: surface wave dispersion curve inversion using Monte Carlo sampling. The 1d modal approximation code used to compute dispersion curves is from Computer Programs in Seismology. This package by xin2zhang provides a Python interface for the original Fortran code.

MCTomo: 3D Monte Carlo tomography package using reversible jump McMC method and 3D Voronoi tessellation, by Xin Zhang and Andrew Curtis

mesoscale Hydrological Model (mHM): mHM is based on accepted hydrological conceptualizations and is able to reproduce as accurately as possible not only observed discharge hydrographs at any point within a basin but also the distribution of soil moisture among other state variables and fluxes.

pyOM2: ocean circulation model with Fortran and Python front end, by ceden

Routing Application for Parallel computatIon of Discharge (RAPID): river network routing model, by Cedric H. David et al. Given surface and groundwater inflow to rivers, this model can compute flow and volume of water everywhere in river networks made out of many thousands of reaches.

seismo-fortran: utility modules for dealing with generally-anisotropic elastic constants and other geophysics problems, by Andy Nowacki

Telewavesim: teleseismic body wave modeling through stacks of (submarine/anisotropic) layers, by Pascal Audet

Topo: NCAR global model topography generation software for unstructured grids


firingcosts_petit2021: replication package for the working paper Aggregate effects of firing costs with endogenous firm productivity growth (2021) by Borja Petit. The codes use OpenMP for parallelization and GNUplot to generate the graphs.

File I/O

flexout: Fortran-based flexible output manager with support for NetCDF and text formats, by Jorn Bruggeman et al.

qfyaml: quick Fortran YAML parser, by Bob Yantosca

Return of JSON for Fortran (rojff): with an interface inspired by jsonff, the data semantics and parser are redesigned to allow for high performance, by Brad Richardson and kmorris

Finite Elements

feappv: free personal version of the FEAP (A Finite Element Analysis Program), associated with the book The Finite Element Method: Its Basis and Fundamentals, 7th ed., by O.C. Zienkiewicz, R.L. Taylor and J.Z. Zhu, Elsevier, Oxford, 2013

Fortran Books and Tutorials

Introduction to Modern Fortran: aimed at users and developers who know how to program, but have little or no experience in Fortran, and those who may wish to have a refresher in Fortran, by Kevin Stratford

rocket-science: case study in modernizing legacy Fortran software, by Brad Richardson et al. This repository contains a modern mini-application for simulating solid rocket motors using an object-oriented, functional programming style in Fortran 2018, a legacy motor simulator demonstrating the solution of the same governing equations using a procedural programming style in Fortran 77/90, and a refurbished motor simulator demonstrating one modernization path for making the legacy solver object-oriented but without the radical redesign that affords the above purely functional programming style.

Upgrading-to-Fortran90: programs from Upgrading to Fortran 90 by Cooper Redwine (1995)

General Purpose

argv-fortran: a better get_command_argument for Fortran that returns the argument in an allocatable character string, by Jacob Williams

cpu_timer: Fortran 2008 object-oriented library for computing elapsed CPU time, by Jon Lo Kim Lin

erloff: errors and logging for Fortran, by Brad Richardson. The basic usage is that a procedure can have intent(out) message and/or error list arguments, or as a component of its return value.

Fortran Input Parser: typical application is the reading in of input parameters (input file) and material parameters (database) from two text files for e.g. a scientific code

Quantities for Fortran (quaff): makes math with units more convenient, by Brad Richardson et al. This library provides all the functionality necessary to almost treat quantities with units associated with them as though they were just intrinsic real values

SQLite for Fortran (sqliteff): thin wrapper around the SQLite library, by Brad Richardson. The sqliteff_* functions are effectively identical to the sqlite3_* functions that would be called from C, but with Fortran intrinsics and types.

TimerClass: object-oriented Fortran 2003 timer class, by Danny Vanpoucke

Graphics, Plotting, and User Interfaces

Dislin_x_y_plot: generates plots from within a Fortran program nearly as easily as with the provided Dislin “quickplots”, by Andi Zuend. However, unlike the quickplots, this module offers a lot more options for controlling the plot page, axis system and various curve properties. It also makes adding multiple x–y data sets (curves) to a single plot easy.


fortran-c-cpp-interface: interoperability examples between C, C++ and Fortran, from scivision. Uses the standard C binding to define variable and bind functions/subroutines.

fpydemo: demonstration of packaging a command line tool written in Python and Fortran, by Saikat Banerjee. The minimum working example has native Fortran codes compile to a shared library with F2PY, Lapack routines, and uses mpi4py for MPI parallelization.

Tcl/Tk 8.6 for Fortran 2018: ISO_C_BINDING interface library for interoperability with Tcl/Tk 8.6, by interkosmos, allowing the user to embed Tcl into Fortran, create Tcl extensions in Fortran (with Tcl Stubs), access (a subset of) the Tcl/Tk C API from Fortran, use Tcl as an evaluatable configuration file format, and add graphical user interfaces to Fortran programs.


lagrange_interpolator: OOP library for 1 and 2-dimensional Lagrange interpolation, by Jon Lo Kim Lin

Linear Algebra

amg4psblas: Algebraic Multigrid Package based on PSBLAS (Parallel Sparse BLAS version 3.7), for the iterative solution of large and sparse linear systems, by sfilippone et al.

qrupdate-ng: library for fast updating of QR, LU, and Cholesky decompositions, by Jaroslav Hajek, updated by M. Koehler and C. Himpe

STCollection: contains matrices that have been used for testing LAPACK’s symmetric tridiagonal eigensolvers and bidiagonal SVD algorithms. The collection includes symmetric tridiagonal matrices and (upper) bidiagonal matrices. The original set of matrices in the collection has been described in Marques, Demmel, Voemel, and Parlett, A Testing Infrastructure for Symmetric Tridiagonal Eigensolvers, ACM TOMS, 35:2008.


MPFUN2020: thread-safe arbitrary precision package that enables one to perform floating-point computations (real and complex) to arbitrarily high numeric precision, by making only relatively minor changes to existing Fortran-90 programs (mostly changes to type statements), by David H. Bailey. All basic arithmetic operations and transcendental functions are supported, together with several special functions. FPM package by Jacob Williams here

pypolsys: Python wrapper to POLSYS_PLP Fortran 90 package from Layne T. Watson, Steven M. Wise, Andrew J. Sommese, August, 1998. POLSYS_PLP is a solver for N complex coefficients polynomial systems of equations in N unknowns by a probability-one, globally convergent homotopy method.

special_functions: Cython and Python API for some Fortran and C libraries of special functions, by Siavash Ameli

Warton Legacy: RSA code scrambling and unscrambling, code generating via robust prime construction, code breaking and secret sharing, by Robert Warton. Routines in number theory and algebraic numbers exist both within programs and separately.

Ordinary Differential Equations

dde_solver: update by Warren Weckesser of Shampine and Thompson’s DDE_SOLVER, a Fortran library for delay differential equations


EMSOL: primal simplex linear programming solver

FortranFilterSLP: for a particular class of non-convex nonlinear programming problems, this implementation of FilterSLP by jajhall uses sequential linear programming to find a (local) optimal solution.

L-BFGS-B-NS: code for thesis by Wilmer Henao, An L-BFGS-B-NS optimizer for non-smooth functions

libdogleg-f: Fortran bindings to libdogleg - a large-scale nonlinear least-squares optimization library, by Ivan Pribec. Currently only the dense optimizer calls are supported.

Trust Region Derivative-Free algorithm (TRDF): by F. N. C. Sobral. Reference: P. D. Conejo, E. Karas, and L. G. Pedroso, A trust-region derivative-free algorithm for constrained optimization, Optim. Methods Softw., vol. 30, no. 6, pp. 1126–1145, Nov. 2015. Also vkpss: algorithm based on sampling approaches for building models in derivative-free trust-region optimization problems, skinny: derivative-free direct search algorithm for constrained problems, fird: solves general derivative-free constrained optimization problems in which the derivatives of the objective function are not available

Parallel Programming

Coarray Collectives: module aims to provide various collective parallel procedures for Fortran coarray programs, by Neil Carlson. These are in addition to the several intrinsic collectives introduced in Fortran 2018. Currently the module provides a single procedure, co_sum_scan which computes a prefix sum across all images, similar to MPI_Scan.

Examples from OpenMP Application Programming Interface: examples from OpenMP Application Programming Interface in Fortran, C, and C++

Index Map: index_map_type Fortran module, by Neil Carlson, provides core capabilities that support use of distributed arrays in MPI-based SPMD programs through the index_map derived type that describes the mapping of an array’s index set to processes. The mapping allows for overlap between processes, and provides collective array gather procedures and scatter reduction procedures associated with that overlap.

INHDF5: various utilities for using the parallel HDF5 library with MPI and Fortran, by Ioannis Nompelis

INshm: library for accessing chunks of shared memory across process running on a Unix host in Fortran, by Ioannis Nompelis

Partial Differential Equations

spherepack: computes common spherical differential operators including divergence, vorticity, latitudinal derivatives, gradients, the Laplacian of both scalar and vector functions, and the inverses of these operators, by Jon Lo Kim Lin. For example, given divergence and vorticity, the package can be used to compute velocity components, then the Laplacian inverse can be used to solve the scalar and vector Poisson equations.

Particle Physics

JHUGen: generator giving parton-level information including full spin and polarization correlations for the processes ab → X → VV (V=Z,W,gamma), VBF, X+JJ, pp → VX, ee → VX

Plasma Physics

Flexible Optimized Coils Using Space curves (FOCUS): nonlinear optimization code for designing 3D coils. Its sibling, FAMUS, can be use to design permanent magnets.


flex-general: applies the Fluctuation Exchange Approximation (FLEX) to study superconductivity and magnetism in multiband tight-binding models, by John Deisz. flex-stripes analyzes charge and magnetic stripe formation in one-band tight-binding models.

Generalized Spallation Model and Event Generator: composed of several sub-models, consisting primarily of the Standard and Modified Dubna Cascade Models (DCM), a Coalescence model, Preequilibrium model, and the GEM2 (Generalized Evaporation Model), being used for simulating compound Evaporation and fission, from Los Alamos National Laboratory.

IrisFDTD-Academic: implements the Finite-Difference Time-Domain (FDTD) method. It is a “toy version” of the IrisFDTD program, a Maxwell’s equations solver in the field of computational electrodynamics for photonics and nanotechnology, by Sergio G Rodrigo.

Koko Optical Design Software (KODS): raytracing software for the design and analysis of optical imaging and illumination systems. Koko has evolved from the optics design program KDP-2 that was made open-source by its original developer James E. Klein.

Uppsala Atomistic Spin Dynamics software (UppASD): simulation suite to study magnetization dynamics by means of the atomistic version of the Landau-Lifshitz-Gilbert (LLG) equation, by Anders Bergman et al. Related book: Atomistic Spin Dynamics: Foundations and Applications

Quantum Chemistry and Electronic Structure

ddX: package for continuum solvation models based on the domain decomposition paradigm. It contains a common interface for the three different methods ddCOSMO, ddPCM and ddLPB for the numerical solution to the COSMO, PCM and LPB solvation models, by mnottoli et al.

Environ: computational library aimed at introducing environment effects into atomistic first-principles simulations, in particular for applications in surface science and materials design

Humble Interface for Vasp outputEditing (HIVE4-tools): Post-processing tool-set for ab-intio calculations obtained with VASP, by Danny Vanpoucke

libconeangle: library for calculating exact ligand cone angles according to the paper Bilbrey, J. A.; Kazez, A. H.; Locklin, J.; Allen, W. D. Exact Ligand Cone Angles. Journal of Computational Chemistry 2013, 34 (14), 1189–1197.

Molecular Orbital KIT (MOKIT): utilities and modules to transfer MOs among various quantum chemistry software packages, by jxzou. In addition, the automr program in MOKIT can set up and run common multi-reference calculations in a block-box way.

nonadiabatic statistical theory (NAST) package: predicts kinetics of spin-dependent processes, including intersystem crossings, spin-forbidden reactions, and spin crossovers, by Sergey Varganov. The NAST package can calculate the probabilities and rates of transitions between the electronic states of different spin multiplicities.

Random Number Generation

M_random: module of pseudo random procedures, by urbanjost


orderpack: clone by urbanjost of Orderpack 2.0 from Michel Olagnon that has been restructured so as to be useable as an fpm package. It provides order and unconditional, unique, and partial ranking, sorting, and permutation.


Bayesian Modeling (BaM): framework aimed at estimating a model using a Bayesian approach and using it for prediction, with a particular focus on uncertainty quantification, by Ben Renard and Emeline Perret

fsklearn: simple module for machine learning in Fortran using scikit-learn, by Zhouteng Ye. The module can be used to do training and prediction in Fortran, the training part uses scikit-learn library by calling Python from Fortran, and the prediction part, as it may be called frequently by a Fortran code, is written in Fortran 2003.

Fortran: programs and subroutine libraries useful in statistical analysis and quantitative genetics. Some are by Neville Jackson and others are collected from the public domain.

SLICE: efficient N-Dimensional Monte Carlo inversion algorithm, by ericlindsey


fString: contains methods to add strings to values or split the context of a string of more than one substrings or even extract specific values using the pattern method, by Dionisis Pettas. The main idea comes from Python and how uses its strings.

iso_varying_string: implementation of the ISO_VARYING_STRING module as defined in the ISO standard, by Brad Richardson

parff: functional style parser combinator library, by Brad Richardson and Patrick Raynaud. By using a library like this, it is possible to implement parsers for complex formats by composing independent little pieces.

ryu_fortran: Ryu algorithm which converts floating point numbers to decimal strings, by St Maxwell. It is more effective than internal file approach. This implementation is based on the Scala version of Ryu.

strff: library of string functions, by Brad Richardson

Time Series

SLICOT System Identification Toolbox: includes SLICOT-based MATLAB and Fortran tools for linear and Wiener-type, time-invariant discrete-time multivariable systems. Subspace-based approaches MOESP - Multivariable Output-Error state SPace identification, N4SID - Numerical algorithms for Subspace State Space System IDentification, and their combination, are used to identify linear systems, and to initialize the parameters of the linear part of a Wiener system. See also SLICOT Basic Systems and Control Toolbox and SLICOT Library.

Unit Testing

Testing Or ASsertion Toolkit (TOAST): unit testing library by thomasms and Bob Apthorpe

Vegetables: unit testing framework written using functional programming principles, by Brad Richardson. As many of its procedures as possible are marked with the pure keyword, while still allowing the framework to test impure code.

XFunit: object oriented framework to implement unit testing in Fortran 2018, by Fran Martinez Fadrique. Unit testing with XFunit is structured in suites and units. A test suite typically define all test to be implemented for a Fortran module.


I appreciate the publicity, but I think @rouson should probably be listed as first author on this one.

Could you update this entry to veggies/garden?