Fortran Language Reference and Its Evolution

Sources and Grounding Material

• mission: Fortran and scientific computing: language references, numerical methods, and high-performance computing resources.
• editorial_style: reference
• primary_topics: Fortran language reference; numerical methods; high-performance computing; scientific software ecosystem
• excluded_topics: law or legal services; politics; medical advice beyond general wellness; any Axis client or legal domain references
• Fortran Intrinsics Quick Reference | GFortran Reference Published 2026-08-21 · by the editorial team By the GFortran Reference Editorial Team First published August 21, 2026 · Last updated August 21, 2026 Numeric intrinsics abs(x) — the absolute value of a number. sqrt(x) — the square root. mod(a, b) — the remainder of a divided by b. max(a, b, ...) / min(a, b, ...) — the largest / smallest of the arguments. nint(x) — the nearest whole number to x. sin(x) , cos(x) , tan(x) , exp(x) , log(x) — the standard elementary functions. Array intrinsics sum(array) — the sum of the elements. product(array) — the product of the elements. maxval(array) / minval(array) — the largest / smallest element. dot_product(a, b) — the dot product of two rank-one arrays. matmul(a, b) — matrix multiplication of two rank-two arrays. size(array [, dim]) — the number of elements, or the extent along one dimension. shape(array) — the extents of each dimension. transpose(matrix) — the transpose of a rank-two array. Inquiry intrinsics kind(x) — the kind type parameter of a value. len(string) — the length of a character value. present(argument) — whether an optional dummy argument was supplied. Using the reference The entries above are the intrinsics that appear most often in everyday Fortran. Each takes the standard types and returns the type its name suggests; element-wise functions such as sqrt are elemental, meaning they work on a whole array as easily as on a scalar. A short example: program quick_example implicit none real :: x = -3.5 integer :: r r = mod(10, 4) print *, 'abs of x: ', abs(x) print *, '10 mod 4: ', r end program quick_example For the surrounding language features these intrinsics operate on, see Arrays and Intrinsic Functions . Keep reading Arrays and Intrinsic Functions Resources hub About the author GFortran Reference Editorial Team GFortran Reference is written and reviewed by its editorial team. We publish independent educational publication on the Fortran language and scientific computing - not part of the GNU project, and we review and update articles on a regular cycle. Read our editorial standards and corrections policy .
• Getting Started with Fortran: A Guide | GFortran Reference Published 2026-08-21 · by the editorial team By the GFortran Reference Editorial Team First published August 21, 2026 · Last updated August 21, 2026 A language built for computation Fortran is one of the oldest programming languages still in wide use. It was developed in the 1950s to let scientists and engineers write numerical programs in something close to mathematical notation, and its design has always favored the needs of numerical work: efficient arithmetic, strong array handling, and a syntax that stays close to the formulas being computed. The standards timeline Fortran has been an internationally standardized language since the 1960s, which is one reason programs written decades ago can often still be compiled today. The major standards, in order: FORTRAN 66 — the first standard, published in 1966. FORTRAN 77 — a major revision published in 1978. Fortran 90 — published by ISO in 1991; introduced free source form, modules, array operations, and derived types. Fortran 95 — published in 1997; a smaller revision adding features such as pure and elemental procedures. Fortran 2003 — published in 2004; added object-oriented features, allocatable enhancements, and more. Fortran 2008 — published in 2010; introduced coarrays and the DO CONCURRENT construct. Fortran 2018 — published in 2018; extended coarray facilities and added further enhancements. Fortran 2023 — published in 2023; the most recent revision. Fixed and free source form Programs written for the older standards use fixed source form, in which columns of each line have special meaning. Since Fortran 90, free source form has been available: statements may start in any column, lines may be long, and comments begin with an exclamation mark. Most new code is written in free form, and the examples on this site use it throughout. First steps for new programmers If the language is new to you, a steady path looks like this: Learn the shape of a program — the program statement, declarations, and the end program statement — using the Hello World article . Practice with variables of the basic types (integer, real, character, logical) and simple arithmetic. Move to arrays and intrinsic functions, where Fortran does much of its best work, via Arrays and Intrinsic Functions . Add file input and output with Reading and Writing Files . Then follow the links into the numerical methods and performance sections as your programs grow. Use any compiler that supports the standard you are targeting, and rely on its documentation for the details of compiling on your system. This site covers the language, not the tools. Keep reading Hello World and the Basics Arrays and Intrinsic Functions All guides About the author GFortran Reference Editorial Team
• Fortran Performance: The Basics Guide | GFortran Reference Published 2026-08-21 · by the editorial team By the GFortran Reference Editorial Team First published August 21, 2026 · Last updated August 21, 2026 Why performance matters in science Scientific programs often run for hours or days, so a program that runs twice as fast can change what research is practical. Performance work in scientific computing concentrates on the few places where most of the time goes — usually loops over large arrays — rather than on polishing every line. What compilers do A compiler translates source code into machine instructions, and an optimizing compiler works hard to make that translation fast: it removes computations whose results are never used, replaces repeated calculations with cheaper equivalents, reorders and unrolls loops, and uses vector instructions that operate on several numbers at once. Optimization is typically selected with command-line flags that trade compile time against runtime speed. The compiler can only apply these transformations where the code's meaning is clear, so writing loops and array expressions in a straightforward style helps the optimizer do its work. More detail is in Optimization Concepts . Memory and locality Modern processors read from memory much more slowly than they compute, so programs that reuse nearby data — good locality — run far faster than programs that jump around. Fortran stores array elements column by column in memory, so loops that step through the first array index innermost touch memory in order and cache well. Simply matching loop order to the storage order is one of the most effective performance habits available. Measure before you optimize Guessing where a program is slow is unreliable. The dependable workflow is to time the program, find the routines that dominate the runtime, change only those, and compare against the saved timings. The measurement-first workflow article describes the loop in full. Keep reading Optimization Concepts A Measurement-First Workflow All guides About the author GFortran Reference Editorial Team GFortran Reference is written and reviewed by its editorial team. We publish independent educational publication on the Fortran language and scientific computing - not part of the GNU project, and we review and update articles on a regular cycle. Read our editorial standards and corrections policy .
• Why Fortran still matters in science — GFortran Why Fortran Still Matters in Science Despite its age, the programming language Fortran remains an essential tool for scientific research and computational modeling. Developed in the 1950s, Fortran was designed specifically for high-performance computing needs and has since become a staple in fields such as physics, chemistry, meteorology, and engineering. #### High-Performance Computing One of the key advantages of Fortran is its efficiency in handling large-scale numerical computations. Modern scientific research often involves complex simulations and extensive data analysis, where performance is crucial. Fortran's straightforward syntax and optimized compilers make it well-suited for writing fast and efficient code. This makes it a preferred choice for tasks like weather forecasting, climate modeling, and computational fluid dynamics. #### Legacy Codebase Fortran has an enormous legacy codebase that continues to be relevant in scientific computing. Many established algorithms, models, and simulations are written in Fortran due to its long history of use in the field. Maintaining compatibility with this existing code allows researchers to build upon decades of work rather than starting from scratch. Moreover, new developments often integrate with or enhance these legacy systems, ensuring that older codes remain valuable. #### Active Development Community Contrary to popular belief, Fortran is not a dead language but one actively developed and supported by both scientists and programmers. The Free Software Foundation maintains GFortran (GNU Fortran), which is an open-source implementation of the Fortran standard and supports modern features such as object-oriented programming. This community-driven development ensures that Fortran stays up-to-date with current computing trends while retaining its strengths in scientific computation. #### Interoperability Fortran has strong interoperability capabilities, allowing it to interface easily with other languages like C or Python. This feature enables scientists to leverage the best of multiple language ecosystems for their projects. For instance, researchers can use Fortran for computationally intensive tasks and Python for scripting and visualization, creating a powerful hybrid solution. #### Educational Value Learning Fortran provides students with a solid foundation in scientific computing principles. The simplicity of its syntax makes it easier to understand basic programming concepts without the complexity sometimes found in newer languages. This educational benefit ensures that future scientists are well-equipped to work effectively with legacy systems and contribute meaningfully to ongoing research projects. In conclusion, despite being one of the oldest high-level programming languages, Fortran's relevance in scientific computing remains undiminished due to its performance capabilities, extensive codebase, active development community, interoperability features, and educational value.
• Getting started with modern Fortran — GFortran Getting Started with Modern Fortran Using GFortran Fortran, originally developed in the 1950s for scientific computing, has evolved into a powerful language used extensively in fields such as physics, engineering, and meteorology. GNU Fortran (GFortran) is an open-source compiler that supports modern Fortran standards and provides extensive features for developers. #### Setting Up GFortran To begin using GFortran, you need to install it on your system. Here’s a brief guide on how to do this: 1. **Installation**: You can download the latest version of GFortran from the GNU Project website or use package managers like `apt` for Debian-based systems (e.g., Ubuntu) or `brew` for macOS. For example, in Ubuntu, you can install it using: ```bash sudo apt-get update sudo apt-get install gfortran ``` 2. **Verification**: After installation, verify the installation by checking the version of GFortran installed on your system. ```bash gfortran --version ``` This command will display the installed version number and confirm that GFortran is set up correctly. #### Writing Your First Fortran Program Let’s start with a simple "Hello, World!" program to familiarize you with basic syntax: 1. **Create a File**: Open your preferred text editor or IDE (Integrated Development Environment) and create a new file named `hello.f90`. 2. **Write the Code**: ```fortran program hello_world implicit none print *, 'Hello, World!' end program hello_world ``` 3. **Compile the Program**: Use GFortran to compile your code. ```bash gfortran -o hello_world hello.f90 ``` 4. **Run Your Program**: ```bash ./hello_world ``` This will output `Hello, World!` in your terminal. #### Key Features of Modern Fortran Modern Fortran includes features such as modules, classes, and operator overloading that make it more versatile than its older counterparts: 1. **Modules**: Modules allow you to encapsulate data and procedures, which can then be imported by other programs or subroutines. ```fortran module constants implicit none real(kind=8), parameter :: pi = 3.141592653589793d0 end module constants ``` 2. **Classes**: Fortran's object-oriented capabilities include support for classes and inheritance, enabling more complex program structures. ```fortran type :: Point real :: x, y contains procedure :: move => point_move end type Point subroutine point_move(this) class(Point) :: this ! Move the point based on some criteria end subroutine point_move ``` 3. **Operator Overloading**: You can redefine operations for your custom types. ```fortran interface operator (+) module procedure add_point end interface function add_point(a, b) result(c) type(Point), intent(in) :: a, b type(Point) :: c c%x = a%x + b%x c%y = a%y + b%y end function add_point ``` #### Conclusion Getting started with modern Fortran using GFortran provides you with a robust platform for scientific computing and high-performance numerical analysis. With its powerful features like modules, classes, and operator overloading, Fortran remains an excellent choice