New Fortran projects

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.

2 Likes

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.

Benchmarks

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.

Interoperability

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

Numerical

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

Physics

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.

Statistics

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

Strings

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.

6 Likes

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.

Benchmarks

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

Economics

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.

Interoperability

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.

Interpolation

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.

Numerical

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

Optimization

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.

Physics

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

Sorting

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.

Statistics

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

Strings

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.

5 Likes

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?

Update since April 21, 2022. Going forward, to save time, I will not be looking for and adding new packages in scientific domains, such as Astronomy and Astrophysics or Earth Science, but I will still periodically scan for new packages to solve numerical problems, such as optimization or quadrature. I will add any projects submitted in issues that people think are noteworthy.

Astronomy and Astrophysics

optool: computes complex dust particle opacities from the command line, by Carsten Dominik and Ryo Tazaki. It is derived from Michiel Min’s DHS OpacityTool and also implements Ryo Tazaki’s MMF theory for highly porous aggregates.

White Dwarf Evolution Code (WDEC): code associated with paper WDEC: A Code for Modeling White Dwarf Structure and Pulsations (2018), by Agnès Bischoff-Kim and Michael H. Montgomery

Code Tools

AD_dnSVM: Fortran Automatic Differentiation tool using forward mode for scalars (S), Vectors (V) and Matrices (M), by David Lauvergnat. It has no limit in terms of the number of independent variables (this number is defined at runtime) and can compute up to third derivatives.

exceptions: experiment with exceptions in Fortran via a simple preprocessing step, by Arjen Markus

symengine.f90: Fortran wrappers by Rikard Nordgren and Ondřej Čertík of SymEngine, a fast symbolic manipulation library, written in C++

Compiler Tests

paranoia: tests floating-point arithmetic in a Fortran programming environment, by urbanjost. This is a version of the netlib PARANOIA Fortran programs converted to procedures. They can be embedded into programs such that one can verify the behavior of the options selected to execute a program, or the simple test program can be used to experiment with various compiler selections.

Containers and Generic Programming

M_anything: use polymorphism to allow promoting, casting and molding intrinsic types, by urbanjost

Earth Science

CFMIP (Cloud Feedbacks Model Intercomparison Project) Observation Simulator Package (COSP): takes the models representation of the atmosphere and simulates the retrievals for several passive (ISCCP, MISR and MODIS) and active (CloudSat (radar) and CALIPSO (lidar)) sensors

Error Handling

errstat: error status and message handling library for Modern Fortran, by Tomohiro Degawa

FException: provide an easy but flexible mechanism for handling errors in Fortran, from csbrady-warwick. FException does not try to implement C++/Python style exceptions but has its own approach that is a mixture of classical exceptions with propagating error codes

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

Fortran Error Handling: makes error handling easier by providing a type, error_t, to indicate if a procedure invocation has failed, from SINTEF. Errors can be handled gracefully and context can be added while returning up the call stack. It is also possible to programmatically identify and handle certain types or errors without terminating the application. It generate stacktraces along with any error when combined with the Fortran Stacktrace library, which enables generation of stacktraces for Fortran by wrapping the C++ library backward-cpp.

Expression Parsers

Fortran Function Parser (ffp): evaluates a string containing a mathematical expression that can be formed by numbers, brackets, functions, and variables, by Wilton P. Silva and Ivomar B. Soares

Fortran Parser: parser of mathematical expressions by hennink and Jacopo Chevallard, based on Roland Schmehl’s fparser

M_matrix: Fortran callable version of old matlab-like interface, by urbanjost

Fast Fourier Transform

fstpack: library of Fast Stockwell transforms, including CUDA support, by Thomas Kreuzer

Finite Elements

Finite Element Multiphysics PARallel solvers (FEMPAR): scientific software for the simulation of problems governed by partial differential equations (PDEs). It provides a set of state-of-the-art numerical discretizations, including finite element methods, discontinuous Galerkin methods, XFEM, and spline-based functional spaces.

Fortran Books and Tutorials

Introduction to Fortran Debugging: reviews the most common types of errors and
present simple ways to locate and correct those errors without the use of any debugging applications, by Andres Perez Hortal. The common errors are illustrated using simple Fortran applications where the simple debugging techniques are applied.

Games

adventure: original Fortran version of Adventure by Will Crowther, updated by ghfbsd to work with a modern Fortran compiler

General Purpose

Algorithms: The Laboratory of Algorithms, by Andrey Pudov.

Fortran IFS and Arpege Toolkit (FIAT): collection of selected Fortran utility libraries, extracted from the IFS/Arpege model, including drhook for tracing, gstats for timing, parkind to choose precision, mpl for MPI communication, mpi_serial for MPI dummy symbols compiled into static library, and other routines

fortran-sleep: OS/compiler-independent “sleep” Fortran subroutine that calls c_sleep, from scivision

funx: Unix commands from Fortran via calls to C, by tranqv

reference-counter: object-oriented, extensible reference-counting utility for Fortran, by Damian Rouson et al.

Graphics, Plotting, and User Interfaces

Fortran Terminal (fortty): create colorful terminal applications in Fortran, by Sebastian Ehlert

pyplot-fortran: generate plots from Fortran using Python’s matplotlib.pyplot, by jacobwilliams

Interoperability

call_py_fort: call Python from Fortran, by Noah D. Brenowitz. Operates by pushing Fortran arrays into a global python dictionary, calling Python functions with this dictionary as input, and then reading NumPy arrays from this dictionary back into Fortran.

Interpolation

pytspack: Python wrapper by Barry Baker and Zachary Moon of Robert J. Renka’s TSPACK, a curve-fitting package based on exponential tension splines with automatic selection of tension factors

SHEPPACK: modified Shepard algorithm for interpolation of scattered multivariate data, by William Thacker and Layne Watson. It is Algorithm 905 of ACM Transactions on Mathematical Software.

Linear Algebra

Automatically Tuned Linear Algebra Software (ATLAS): applies empirical techniques in order to provide portable performance. At present, it provides C and Fortran77 interfaces to a portably efficient BLAS implementation, as well as a few routines from LAPACK.

Sparse Iterative parallel linear solver: developed in Fortran/OpenMP by Tue Bosen, and designed with focus on speed especially in parallel. The code uses a block-splitting of the linear system without any overlap. It is intended to be used on matrices which have already been reordered using a reverse Cuthill-Mckee reordering.

Neural Networks and Machine Learning

fortran2xgb: interface for calling XGBoost from Fortran, by Christoph Keller. The idea is to train an XGBoost model externally, e.g. in Python, then save that model to disk (in the XGBoost internal binary format, e.g. using Booster.save_model() in Python), and later call the model from Fortran to make a prediction.

Numerical

ForTrilinos: provides Fortran interfaces for the following capabilities of the C++ Trilinos library: Parameter lists and XML parsers (through Teuchos); Distributed linear algebra object including sparse graphs, sparse matrices, and dense vectors (through Tpetra); Linear solvers and preconditioners (through Stratimikos, Ifpack2, Belos, MueLu); and Eigen solvers (through Anasazi).

HOMPACK90: solves nonlinear systems of equations by homotopy methods. There are subroutines for fixed point, zero finding, and general homotopy curve tracking problems, utilizing both dense and sparse Jacobian matrices, and implementing three different algorithms: ODE-based, normal flow, and augmented Jacobian. Associated paper: Algorithm 777: HOMPACK90: a suite of Fortran 90 codes for globally convergent homotopy algorithms, by Layne T. Watson et al.

Jacobi Theta functions for Fortran: by Mikael Fremling

specfunc-fullerton: library for evaluating special mathematical function, based on the fn library of Wayne Fullerton, modernised by Arjen Markus. It has Airy functions, modified Bessel functions, beta functions, exponential and logarithmic integrals, gamma functions, inverse cosine and cosine hyperbolic integrals, miscellaneous functions, and Pochhammer symbols

Optimization

L-BFGS-B_wrapper_f90: Fortran 90 wrapper of L-BFGS-B local minimization routine, by Mingda Zhang

pdfo_ref: reference implementation of Powell’s derivative-free optimization solvers, namely COBYLA, UOBYQA, NEWUOA, BOBYQA, and LINCOA, by Zhang Zaikun and Tom M. Ragonneau. The goal is to implement these solvers in modern languages — first modern Fortran (F2003 or later), and then MATLAB, Python, and probably Julia and R. It will be a faithful implementation, in the sense that the new code will be mathematically equivalent to Powell’s, except for the bug fixing and improvements that we make intentionally.

VTDIRECT95: implementation of D. R. Jones’ deterministic global optimization algorithm called DIRECT, which is widely used in multidisciplinary engineering design, biological science, and physical science applications, by Layne T. Watson and Masha Sosonkina. The package includes both a serial code and a data-distributed massively parallel code for different problem scales and optimization (exploration vs. exploitation) goals.

VTMOP: Solver for Blackbox Multiobjective Optimization Problems: package containing a robust, portable solver and a flexible framework for solving MOPs, by Tyler Chang and Layne Watson. Designed for for efficiency and scalability to an arbitrary number of objectives, VTMOP attempts to generate uniformly spaced points on a (possibly nonconvex) Pareto front with minimal cost function evaluations.

Parallel Programming

Advanced Parallel Programming: exercise material and model answers for a CSC course. Other CSC courses are Elements of high-performance computing and Parallel Programming with MPI and CSC Summer School in High-Performance Computing 2022.

CUDA Fortran: Fortran programming on GPU: a complete introduction for beginners by Koushik Naskar

Physics

LINVARIANT: universal model generator in the field of computational condensed matter physics, by Peng Chen et al. Using group theory, it mathematically models physical systems such as lattice, electron, spin and their coupling systems.

w2dynamics: continuous-time hybridization-expansion Monte Carlo code for calculating n-particle Green’s functions of the Anderson impurity model and within dynamical mean-field theory, by Markus Wallerberger et al.

Random Number Generation

mersenne-twister-fortran: Mersenne Twister pseudorandom number generator, by Jacob Williams

Sorting

fsort: uses three different sorting methods to maximize speed within memory constraints, based on the size of the array, by Mingda Zhang

Statistics

FORtran library for Computational Environmental Systems (FORCES): codes for optimization, linear and nonparametric regression, random number generation, numerical integration, and other topics

M_datapac: NIST DATAPAC package modularized and made available as an fpm(1) package, by urbanjost, original code by James Filliben. There are routines for computing various probability functions.

STooDs: framework to build and estimate probabilistic models for data varying in space, time or other dimensions, by Ben Renard

Strings

mod_pcreposix: module for working (in Unix) with the Perl compatible regular expressions, by tranqv

stringmod: Fortran 2008 module by Tom Canich providing string manipulation functions: strtok, ntoken, to_upper, to_lower, rev

Time Series

sacbook: online analysis methods provided in The Seismic Analysis Code: A Primer and User’s Guide by George Helffrich, James Wookey, and Ian Bastow

Unit Testing

FUnit: lightweight library for writing, administering, and running unit tests in Fortran, by Andrey Pudov. It is an instance of the xUnit architecture and provides Fortran programmers a basic testing functionality with a flexible variety of user interfaces.

4 Likes

A post was split to a new topic: Fortran bindings for zlib

This is my first post on the forum, so Hello, folks! :grinning: I am also new to Fortran coming from Rust (literally, just a couple of days ago). This will probably look more like a programming exercise but I hope you will like my code:

8 Likes

Update since July 8

Astronomy and Astrophysics

fastSHT: code associated with the paper Accelerating spherical harmonic transforms for a large number of sky maps, by Chi Tian, Siyu Li, and Hao Liu

Benchmarks

ScalSALE: Scalable SALE Benchmark Framework for Supercomputers, from Scientific Computing Lab NRCN

Biology and Medicine

lungsim (Aether): pulmonary simulation library

Climate and Weather

GEOCLIM-dynsoil-steady-state: computes geographically-distributed chemical weathering rates (along with associated parameters) at steady-state, according to the given climatology (temperature and runoff) for several CO2 levels (2 at least), the topographic slope and the lithology fraction in each grid cell, by Nick Swanson-Hysell and Yuem Park

Containers and Generic Programming

ClassicalDataStructuresF95: classical data structures such as the singly linked list and stack, by truongd and Sessh�maru

Computational Fluid Dynamics

LNS3D compressible Navier-Stokes Solver: part of the Flow Physics & Simulation code suite of fluid mechanics analysis codes to explore linear and nonlinear phenomena, primarily for compressible flows, by S. Scott Collis

Engineering

MPM3D-F90: simplified Fortran 90 version of MPM3D that serves as the companion open source code for the book X Zhang, Z Chen, Y Liu. The Material Point Method - A Continuum-Based Particle Method for Extreme Loading Cases. Academic Press, 2016

Expression Parsers

shunting-yard-fortran: small expression parser using shunting yard algorithm, by Ian Giestas Pauli

File I/O

SDF_FORTRAN: library for accessing files in the SDF (self-descibing file) format, by Keith Bennett et al.

table-for-fortran: table for Fortran working in a similar way as for Astropy or pandas, by aschneeberger. Currently reads and writes csv.

Finite Elements

OpenRadioss: industry-proven analysis solution that helps users evaluate and optimize product performance for highly nonlinear problems under dynamic loadings. For more than 30 years, organizations have used Altair Radioss to streamline and optimize the digital design process, replace costly physical tests with quick and efficient simulation, and speed up design optimization iterations.

Fortran Books and Tutorials

compute-course-public: course material for the COMPUTE course - Scientific Program in Python and Fortran by Jonas Lindemann

Games

SDL77: C library for game programming in FORTRAN 77 that provides some glue code to access the software renderer of SDL 1.2, by interkosmos

General Purpose

Fommons: collection of common low level components to support XFunit, FTL and Frypto, by Fran Martinez Fadrique

fortran-zlib: collection of Fortran 2018 ISO_C_BINDING interfaces to selected zlib functions, by interkosmos. Zlib is a lossless data-compression library.

Frypto: cryptographic library by Fran Martinez Fadrique

mytimer: simple timing routines to be used in codes which use MPI and possibly CUDA, by Pedro Costa

Graphics, Plotting, and User Interfaces

fortran-gdlib: Fortran binding for the GD graphics library, by Johann Andreas Weber

Interoperability

python_from_fortran: examples of calling Python from Fortran using CFFI or Forpy, by halungge

Interpolation

spharm-interp: MATLAB and Fortran routines for interpolation from scattered points on the sphere via spherical harmonics, by Alex Barnett et al.

Linear Algebra

vanhuffel: partial total least squares routines from Sabine Van Huffel

Mesh Generation

gmsh-fpm: provides access to the Fortran F2018 API of Gmsh, examples of how to use the Fortran API, and a Fortran compiled executable for Gmsh itself, by gnikit

Neural Networks and Machine Learning

fortran-ml-bridge: code and examples on directly calling Tensorflow / Pytorch / Keras ML models from Fortran, by Athena Elafrou et al.

Numerical

fctables: computes FC-Gram tables, by Mauro Fontana and sabian2008, using the MPFUN2020 library for arbitrary precision floating point arithmetic. The algorithm is described in the paper Fourier continuation method for incompressible fluids with boundaries

FMPFR: Fortran binding to the GNU MPFR Library multi-precision library, by Thomas Koenig

NumFort: numerical library for FORTRAN that includes quadpack, lapack, PLplot and Matplotlib source code, by Anthony Kalaitzis and Curtis Abell. It enables the use of handy mathematical macros such as linspace.

Optimization

Generalized PROgram for OPTimization (GPROPT): generic tool to minimize a user-defined objective function, by Igor A. R. Lopes. Several classical methods are implemented along with a genetic algorithm.

J: software for mathematical and statistical computations, with special reference to linear programming in forestry, by Juha Lappi

Parallel Programming

first-timer: simple timing routines to be used in codes which use MPI and possibly CUDA/OpenACC using NVTX markers, by Pedro Costa

OpenMP_fortran_codes: basic OpenMP codes written in Fortran, by Kuldeep Tolia

RookieHPC: web site covers major technologies in High-Performance Computing (HPC), such as OpenMP and MPI, providing documentation along with examples, as well as exercises and sometimes tools

standalone_mpi_f08_module: attempt to implement MPI Fortran 2018 support, by Jeff Hammond

Plasma Physics

RAYS: plasma ray tracing code from ORNL-Fusion. The primary objective is to provide a starting point for discussion of what a modern ray tracing code, built on a green-field site might look like.

Physics

Numerical Electromagnics Code (NEC2): UNIX version of NEC2 Antenna Modeler adapted for use with modern computers.

Quantum Chemistry and Electronic Structure

VALENCE: Massively Parallel Implementation of Variational Subspace Valence Bond, by Graham D. Fletcher et al.

Without Empty STates (WEST): massively parallel software for large scale electronic structure calculations within many-body perturbation theory, by Marco Govoni et al.

Random Number Generation

fortran-xorshift-64-star: xorshift64* random number generator for uniform and normal variates, by Jonas-Finkler

Reactor Physics

Stochastic Calculator Of Neutron transport Equation (SCONE): object-oriented Monte Carlo particle transport code for reactor physics, from CambridgeNuclear. It is intended as an accessible environment for graduate students to test and develop their ideas before contributing them to more established codes suitable for design calculations.

Statistics

ecgmm_fortran: Error-Corrected Gaussian Mixture Model algorithm, by Alexey Mints. Based on the paper Hao, J., Koester, B. P., Mckay, T. a., Rykoff, E. S., Rozo, E., Evrard, A., Annis, J., et al. (2009). Precision Measurements of the Cluster Red Sequence Using an Error-Corrected Gaussian Mixture Model. The Astrophysical Journal, 702(1), 745–758.

npregfast: R package with Fortran code for obtaining nonparametric estimates of regression models with or without factor-by-curve interactions using local polynomial kernel smoothers or splines, by Marta Sestelo

tweedie: R code for Tweedie density calculations, including Fortran 77, by Peter K. Dunn

Time Series

EnKF_analysis: EnKF (Ensemble Kalman Filter) analysis routines in Fortran 90, by Geir Evensen. Stochastic and SQRT formulations with subspace inversion. There is a related book.

Unclassified

strengthcalc: strengthcalc employs mathematical formulae from Mayhew et al. (1992) and Wathen (1994) to estimate the maximum weight one can lift in a single repetition of a physical exercise (known as 1RM: one repetition maximum), by Piotr Bajdek

5 Likes

Thanks!

I renamed:

to:

(GitHub redirects automatically the first one to first-timer)

So you could remove mytimer if you wish!

Thanks for keeping up with this nice list!

1 Like

@piotr welcome to the forum, and thanks for the link!

Thanks, @certik! The truth is that I’ve actually switched away from Fortran. I’ve rewritten my program in Rust because of (1) a much better error handling and (2) ease of distribution via crates.io, and declared the Fortran version as deprecated. However, as my tiny Fortran program is included on this list, and even has some clicks and likes, I think I’ll unarchive it, improve the code (subdivide it into modules and add functions) and try to maintain it in parallel with the Rust version. :wink:

3 Likes

Yes, Rust’s package management was the inspiration for fpm. You should make your code an fpm package. As we are improving fpm, it is or will be as easy to install any Fortran package just like it is with a Rust package.

We have many threads here on better error handling for Fortran. What is the error handling approach that you like?

3 Likes

Thanks for the suggestion, @certik. It seems I should largely rewrite the program and its documentation making it an fpm package, which I will do although it’s not my programming priority now.

I don’t want to make a lengthy off-topic in this thread or start a new language battle! I’m afraid that if you follow my purely-amateur suggestions on the package manager, error handling, or virtually any other aspect of the language or its environment, it will be no longer Fortran but a nearly exact clone of Rust. :wink: Also, it will break compatibility with all the code written during the last 65 years while breaking things is precisely the thing I dislike most about certain programming languages…

As I’m not very “technical” I don’t really think too much about the Rust’s famous memory safety–I just get too irritated when something doesn’t work and things get broken, so I seek a solid technology to build on. I open a file. But what if the file does not exist? I should definitely think of a way to handle this situation… and explicitly define the behaviour in my code but also, I don’t want to type too much to handle the error:
let my_text = fs::read_to_string(my_input_file).expect("Something went wrong reading the file!");

And if I don’t handle errors explicitly in my code everywhere an error can potentially occur, like in the Rust example above, in my opinion the source code should never compile! What’s the point in compiling an incorrect program? :stuck_out_tongue_closed_eyes: For an amateur non-professional programmer like me, it is easier to code in Rust than in Fortran because Rust to a higher extent prevents me from doing nonsense things. Also, recently I found very useful Clippy–a tool which helps to enhance the Rust code even more.

I won’t comment on fpm for now–I’m very curious to see how the project develops. But recently, I gave a try the Ada’s Alire package manager which -according to the developers- “aims to fulfill a similar role to Rust’s cargo”. Although I really like the Ada’s design and philosophy I almost immediately uninstalled Alire. I couldn’t see much “similarity” to Cargo. Rust’s crates.io is not a kind of set of links to GitHub repositories and there’s no need to upload Rust code to GitHub! Instead, crates.io is a server the code samples of Rust programmers are “physically” uploaded to for direct download and stored “in perpetuity”. Even if at some point in future I get crazy and yank an uploaded library, my library will stay there available for download forever for the programs which depend on it, no matter what, because the ecosystem must never get broken. As far as I understand, the Ada’s ecosystem based on the Alire package manager does not give me that same guarantee that my programs depending on other people’s libraries won’t suddenly stop to compile because someone has changed something or removed from GitHub.

1 Like

Thanks for the feedback @piotr. Indeed errors should not go silently, I think that can be done even in Fortran without breaking compatibility. Good ideas about uploading to crates.io versus using github to host. Rust is great, you might like our initial Fortran to Rust backend in LFortran: Rust backend by lucifer1004 · Pull Request #812 · lfortran/lfortran · GitHub.

1 Like

:smiley: :smiley: :smiley:

Update since Sep 9, full list here.

Astronomy and Astrophysics

python-fsps: Python bindings to Charlie Conroy’s Flexible Stellar Population Synthesis (FSPS) Fortran code

Biology and Medicine

Motility Analysis of T-Cell Histories in Activation (MATCHA): designs virtual T cells that move like biological T cells, from BerkeleyLab and Northern New Mexico College. The virtual T cells will match the speed and turning angle distributions of biological cells.

Climate and Weather

GemmesF90: code corresponding to paper “Financial impacts of climate change mitigation policies and their macroeconomic implications: a stock-flow consistent approach.” Climate Policy 20.2 (2020): 179-198, by timongo

Containers and Generic Programming

smart-pointers: tracks references to program resources and automates the freeing of those resources if and only if the reference count drops to zero, by Damian Rouson et al. Most commonly, the reference is a pointer and the resource is memory.

Earth Science

fastscapelib-fortran: Fortran (+ Python bindings) library of efficient algorithms for landscape evolution modeling, by Benoit Bovy et al.

GSW-Fortran: Gibbs-SeaWater Oceanographic Toolbox in Fortran, by Glenn Hyland et al.

Halfspace deformation (hdef): forward calculation of displacements, strains, and stresses in an elastic half-space. The sources are fault slip models, using the solutions derived in Okada (1992) and in Meade (2007).

Economics

defaultModel: Fortran+OpenMP implementation of the canonical sovereign default model with long-term debt, by Gabriel Mihalache. Solved with discrete choice methods. The MaturityExtension repo is associated with the paper Sovereign default resolution through maturity extension, Journal of International Economics (2020).

File I/O

io_utilities: modules to help with input and output, by Arjen Markus: cmdparse parser for minimalistic commands (keyword and zero or more arguments), keyvars read in INI-files and fill in the values of the variables automatically, can also save the data in an INI-file, progressbar presents a progress bar on the screen (supports different styles)

nmlinput.f90: helper routines to use namelists as input files, by Loïc Reynier

Games

3Drendering: 3D engine written to Linux framebuffer, ray-casting, by Ross J. Stewart

fcurses: module for Linux terminal control over cursor position, character drawing, raw keyboard input, and simple beep sounds, by Ross J. Stewart. Sufficent to write text based games in Fortran.

General Purpose

xslib - Extra-Small Library: library consisting of useful utilities and functions as stand-in for Fortran “standard” library, by JureCerar. Has modules for string handling, error handling, memory allocation, regression, timing, sorting, statistics, and other topics

Graphics, Plotting, and User Interfaces

fortran2018-asymptote: generate drawings using the Asymptote Vector Graphics Language, by Kevin Matthes

Linear Algebra

madrigal: matrix derivative tests for forward and reverse mode automatic differentiation, by R. Quast

Neural Networks and Machine Learning

fnn: implements simple, sequential neural networks, by CEREA DA-ML team. Once a network is constructed, the forward operator is available with apply_forward and can be applied both in training and inference mode.

roseNNa: fast, portable, and minimally-intrusive library for neural network inference, by Ajay Bati and Spencer Bryngelson. The library is optimized Fortran and outperforms PyTorch (by a factor between 2 and 5x) for the relatively small neural networks used in physics applications, like CFD.

Numerical

fastmath: library for fast, approximate math functions: exp, log, 1/sqrt, by Federico Perini. These functions provide fast, approximate evaluations of the exponential, logarithm and normalization functions in 64-bit precision.

polyroots-fortran: modern Fortran library for finding the roots of polynomials, by Jacob Williams

Ordinary Differential Equations

odepack: Modern Fortran interface by Nick Wogan for the LSODA and LSODAR routines in ODEPACK, which is for solving ordinary differential equation initial value problems. This repository contains a modified version of ODEPACK which is threadsafe.

runge-kutta-fortran: Fixed and variable-step Runge-Kutta solvers in Modern Fortran, by Jacob Williams

Optimization

Open source Fortran Simulated Annealing Module (OpenFSAM): module that can be generally assigned to solve a simulated annealing optimization problem, by Nicholas Herring. A user can easily add this module to any existing modern Fortran program since the module is self contained and sufficiently abstracted.

Random Number Generation

rng_fortran: generates random integers, uniform, normal, and Poisson variates, and random points on a circle or sphere, using the xoroshiro128plus generator, by jannisteunissen

Statistics

fitpack: modern Fortran translation by Federico Perini of the FITPACK package for curve and surface fitting by Paul Dierckx

get_moments: maximum entropy based reconstruction of a function from its moments, by Daniel Price

statislib: library for statistical distributions, by Jim-215-Fisher. The library includes various distributions’ random number generators, probability density function or probability mass function, and cumulative distribution function.

Strings

stringParseMods: routines for easy string parsing and for geometric domains, by Ross J. Stewart

Unit Testing

Fortran Unit Testing Objects (Fortuno): flexible and extensible Fortran unit testing framework for testing serial, MPI-parallelized and coarray-parallelized applications, by Bálint Aradi

7 Likes

As one can see in your postings that follow, you still do look and add :wink: That’s great but if you ever decide to actually stop looking and adding, I’d volunteer for the Astronomy and Astrophysics domain if you shared the places to look.

I periodically do a Github search for “fortran”, ranked by recency, and a search for language:fortran stars:“>0”. To save time I am less likely to add domain-specific projects, but if I see one with many stars, I still do. If anyone thinks there is a noteworthy project to be added, (and if you have suggestions for Astronomy and Astrophysics), please raise an issue at GitHub or message me here.