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.

## Benchmarks

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

## Interoperability

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

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

## Interpolation

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.

## Numerical

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

## Optimization

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

## Statistics

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.

## Strings

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.