What Happened to LINPACK (LINear algebra PACKage)?

LINPACK began as a collection of Fortran subroutines developed in the 1970s by Jack Dongarra, Jim Bunch, Cleve Moler, and Gilbert Stewart, designed to perform numerical linear algebra on supercomputers. Its original purpose was to provide a library for solving systems of linear equations and linear least-squares problems.

The 'LINPACK Benchmark' emerged somewhat accidentally in 1979 as an appendix to the LINPACK user's manual, offering a way for users to estimate execution times for solving a 100x100 matrix problem on various systems. This initial benchmark, known as LINPACK 100, measured performance in MFLOPS (Millions of Floating-point Operations Per Second) and helped compare early supercomputers like the Cray-1.

Over the years, the benchmark evolved to accommodate larger problem sizes and parallel processing. A significant turning point was in 1991 when a version allowing arbitrary problem sizes was introduced, enabling high-performance computers (HPC) to approach their asymptotic performance. This scalable version, known as High-Performance LINPACK (HPL), was adopted in 1993 as the primary metric for the TOP500 list, which ranks the world's most powerful supercomputers twice a year. HPL measures a system's ability to solve a dense system of linear equations using LU decomposition with partial pivoting, focusing on raw floating-point computational power.

While LINPACK's consistent methodology has been crucial for tracking the exponential growth of supercomputing power and fostering competition, its relevance has faced increasing scrutiny, particularly in the 2010s and 2020s. Critics argue that HPL primarily tests compute-bound performance and does not adequately reflect real-world application performance, which is often limited by memory bandwidth, latency, or communication overhead. This became particularly evident with the rise of heterogeneous architectures (e.g., CPUs with GPUs) and data-intensive workloads like those found in artificial intelligence (AI).

In response to these limitations, complementary benchmarks have emerged. The High-Performance Conjugate Gradients (HPCG) benchmark, co-developed by Jack Dongarra and Michael Heroux, was introduced in 2013 to measure performance on sparse matrix computations, which are more representative of many scientific applications. The TOP500 list now includes HPCG rankings alongside HPL. More recently, benchmarks like HPL-MxP (Mixed-Precision) have been developed to assess performance in mixed-precision arithmetic, reflecting the growing use of lower precision in AI workloads.

As of September 28, 2026, LINPACK (HPL) remains the official benchmark for the TOP500 list. The June 2026 TOP500 list saw China's LineShine supercomputer debut at number one, achieving 2.198 exaflops on the HPL benchmark. This system also led the HPCG ranking, demonstrating strong performance across both metrics. However, the broader supercomputing landscape in 2026 is characterized by a divergence: publicly funded exascale systems continue to target high HPL scores, while private companies are building massive AI training clusters that often prioritize different metrics and may not even run HPL. This highlights the ongoing debate about what 'fastest' truly means in the evolving era of high-performance computing and AI.