Fortran at 70: The Enduring Legacy of Scientific Computing's Evergreen

Fortran has reached its seventieth birthday. Born in 1957, this programming language is still active on the front lines of weather forecasting, quantum chemistry, fluid dynamics, and high-performance computing. It is fifteen years older than C and thirty-four years older than Python, yet it remains irreplaceable on many supercomputers.

From Punch Cards to AI Accelerator Cards

Fortran was originally created so that scientists would no longer have to instruct machines line by line in assembly language. It was the first to prove that "high-level languages can also generate efficient code." Over the following seventy years, it evolved through FORTRAN 66, 77, 90, 95, 2003, 2008, 2018, and up to the latest 2023 standard, with each iteration preserving backward compatibility with older code—an extremely rare feat in the history of programming languages.

Today, a large number of core numerical kernels in the world's top supercomputers are still written in Fortran. The U.S. National Weather Service, the European Centre for Medium-Range Weather Forecasts, NASA's simulation systems, and the reference implementations of almost all mainstream linear algebra libraries (such as BLAS and LAPACK) have deep ties to Fortran. As GPUs and AI accelerator cards become the mainstream of computing power, the Fortran community continues to adapt to new hardware through solutions such as OpenMP, OpenACC, and CUDA Fortran.

Column-major order is the array storage convention Fortran has used since its inception: multidimensional arrays are stored contiguously by column in memory, meaning the leftmost index varies fastest. This is exactly the opposite of C/C++'s row-major order. For scientific computing, this convention naturally fits the column-wise access patterns of linear algebra operations, and it also makes it easier for compilers to recognize contiguous memory access, generate SIMD vectorization instructions, and implement more efficient cache prefetching strategies. This is also why libraries such as BLAS and LAPACK, whose reference implementations are in Fortran, can maintain extremely high throughput across a variety of hardware—the data structures and algorithmic access patterns are highly consistent, reducing the transposition and copying overhead of cross-language calls.

Coarrays are a native parallel programming mechanism introduced in Fortran 2008. Developers only need to add a codimension such as [*] when declaring a variable to distribute and access that variable across all images (parallel execution replicas, essentially), coordinating at the syntax level through built-in procedures such as this_image(), num_images(), and sync all. Compared with MPI+C, which requires manual management of communication domains, message tags, and buffers, coarrays write parallel semantics directly into the language, making code more concise and more amenable to static analysis and optimization by compilers.

Why Scientists Still Use Fortran

In discussions in communities such as r/ProgrammingLanguages and Hacker News, developers repeatedly mention several reasons:

• Numerical performance: Fortran's native support for multidimensional arrays and column-major memory layout allow compilers to perform more aggressive vectorization and loop optimization. In many benchmarks, Fortran code is faster than or on par with equivalent C code.
• Code legacy: Decades of accumulated physical models, climate simulations, and engineering computation codebases are enormous, and rewriting them is prohibitively expensive.
• Parallelism and friendliness: Features such as DO CONCURRENT, coarrays, and pure functions make parallel programming more concise to express than MPI+C.
• Stable ecosystem: Toolchains such as gfortran, Intel oneAPI Fortran, and NVIDIA HPC SDK continue to be maintained, and the standards committee remains active.

A developer long engaged in computational fluid dynamics commented: "I use Python for prototyping and Fortran for production. This is not nostalgia, but engineering rationality."

BLAS (Basic Linear Algebra Subprograms) and LAPACK (Linear Algebra PACKage) are the two most fundamental layers of the software stack in numerical computing. BLAS defines low-level operation interfaces such as vector addition and matrix multiplication, while LAPACK implements high-level algorithms such as linear equation solving, eigenvalue decomposition, and singular value decomposition on top of it. Both were originally written in Fortran 77 with publicly available reference implementations, and were later widely replaced by highly optimized versions such as Intel MKL, OpenBLAS, and ATLAS, but their interface conventions have always followed Fortran's calling conventions and column-major assumptions. The underlying linear algebra of virtually every scientific computing language (NumPy, MATLAB, R, Julia) ultimately calls into these libraries, so Fortran is in fact at the foundation of the entire numerical software ecosystem.

DO CONCURRENT is a loop construct introduced in Fortran 2008 and further refined in 2018, used to explicitly declare that there are no order dependencies between iterations of a loop, thereby allowing the compiler to automatically parallelize or vectorize it. It is closer to the language itself than OpenMP's parallel for, and can safely degrade to serial execution on platforms that do not support parallelism, balancing portability and performance expression.

Legacy and Challenges

The biggest problem facing Fortran is not performance, but the talent gap. Most university courses have shifted to Python and C++, and young developers have little exposure to Fortran's syntax and toolchain. The community is working to lower the barrier through the Fortran-lang project, the standard library (stdlib), the package manager (fpm), and modern tutorials. These efforts allow Fortran to gradually fill in the modern development experience while preserving its traditional strengths.

Seventy years is a milestone. Fortran's story shows that as long as a tool continues to create irreplaceable value in a specific domain, it can survive across waves of technological change. For today's developers chasing AI and cloud-native technologies, this is a lesson in "long-termism."

The Fortran-lang project is a modernization initiative launched by the community around 2019, aiming to fill in the modern development infrastructure that Fortran has long lacked. Its core outputs include: stdlib, an official-style standard library providing common functionality such as sorting, string processing, and numerical utilities, making up for Fortran's overly minimalist built-in library; fpm (Fortran Package Manager), a package management and build tool inspired by Cargo and npm, allowing Fortran projects to declare dependencies and build and test with one command; and a unified official website, tutorials, and coordinated work across the compiler ecosystem. This series of efforts seeks to lower the entry barrier for new users and alleviate the talent gap problem.

One-line Summary

Fortran turns seventy, still active on the front lines of supercomputing thanks to its numerical performance and code legacy, but facing a talent gap challenge.

Paragraph Summary

Born in 1957, Fortran was the first programming language to prove that high-level languages could generate efficient machine code. Over seventy years it evolved from FORTRAN 66 to Fortran 2023 while always maintaining backward compatibility, an extremely rare feat in programming language history. Today it remains a core tool for weather forecasting, quantum chemistry, fluid dynamics, and high-performance computing, with deep ties to the reference implementations of mainstream linear algebra libraries such as BLAS and LAPACK. The article analyzes why scientists continue to use Fortran: numerical performance brought by native multidimensional arrays and column-major memory layout, a vast code legacy, parallel features such as coarrays and DO CONCURRENT, and a continuously maintained toolchain ecosystem. Its biggest challenge is the talent gap, and the community is lowering the barrier through modernization projects such as Fortran-lang, stdlib, and fpm, continuing this long-termist technological legacy.