Posted on Sep 8

Fortran’s unlikely comeback from programming’s past to powering AI and HPC

#webdev #programming #ai #devops

From Apollo missions to modern machine learning pipelines, Fortran proves that some legends never really retire.

Fortran wasn’t supposed to make it this far.
It launched in 1957, back when most of us weren’t even an idea yet, and the hottest “user interface” was a stack of punch cards. Everyone assumed it would fade into the background a historical footnote next to COBOL, ALGOL, and other fossilized names.

But here’s the plot twist: Fortran is still here. Not just limping along, but actively powering modern AI frameworks, HPC simulations, and scientific research.
It’s the Dark Souls of programming languages every time you think it’s gone, it respawns, harder than before.

When I first stumbled across a dusty Fortran file in a physics lab repo, I laughed. Then I realized my shiny Python code was actually leaning on it through NumPy. That’s when it hit me: old code doesn’t retire it just hides under the hood, waiting for you to notice it’s carrying the whole raid party.

TLDR: Fortran was the first real “grandparent” of programming languages. It faded when C, Java, and Python took the spotlight, but it never died. Today, thanks to AI and HPC, it’s staging a comeback. This article breaks down:

The first legend of code

Back in 1957, while the rest of the world was still figuring out color TV, IBM quietly dropped a weapon that would change programming forever: Fortran. Short for Formula Translation, it was the first widely adopted high-level programming language.

Think of it like the Pong of coding. By today’s standards it looks primitive, but without it there wouldn’t be a Mario, a Halo, or a Fortnite. Fortran proved that computers could do more than crunch numbers in raw machine code they could run human-readable programs that actually scaled.

And it didn’t just run toy problems. Fortran was the language of NASA’s Apollo program. If you’ve ever looked at those grainy black-and-white photos of astronauts walking on the Moon somewhere deep in the chain of computations, a Fortran routine was grinding away behind the scenes. Weather forecasting, nuclear simulations, and supercomputers all leaned on Fortran.

One professor once told me, “Every scientific lab has at least one Fortran codebase they can’t kill. It’s like a family heirloom nobody knows who wrote it, but everyone’s afraid to delete it.”

Fortran also gave us something devs now take for granted: the compiled high-level language model. Instead of toggling switches or memorizing raw opcodes, you could actually write DO I = 1, 10 and have the machine understand it. That was wizardry at the time.

By the 1970s, Fortran had become the gold standard of scientific computing. Want to simulate weather patterns? Fortran. Nuclear reactors? Fortran. Modeling galaxies? Yep, still Fortran. For decades, if you were doing heavy math, you were basically playing in its arena.

It was the first programming legend the Gandalf of code. Old, powerful, and slightly intimidating, but carrying the fellowship whether you noticed or not.

References:

Why Fortran faded

By the late 1970s and 80s, the programming world had options. C showed up flexing low-level control and portability. C++ added the shiny new buzzword of the era: “object-oriented.” Then came Java in the 90s, promising “write once, run anywhere” (and plenty of runtime errors).

Compared to those, Fortran started to look… old. Its syntax was clunky, its ecosystem tiny, and let’s be honest the vibe was “only used by scientists with tenure and a typewriter in their office.”

I still remember hearing a joke in college:

“The only people writing Fortran are the ones who also still write checks at the grocery store.”

It wasn’t totally fair, but it stuck. Fortran became the butt of memes: the graybeard’s language, the fossil in the codebase, the one tool you prayed your manager wouldn’t assign you to touch.

Meanwhile, Python came along with batteries included, an easier syntax, and growing libraries for science and data. By the early 2000s, if you wanted to crunch numbers, you just fired up NumPy instead of learning decades-old Fortran quirks.

And the jobs market? Forget it. Nobody was browsing LinkedIn thinking “Man, I really hope I get a junior Fortran dev role.” Unless you worked in niche HPC labs or legacy finance systems, the career value of Fortran looked near zero.

But here’s the twist most devs missed: while the mainstream walked away, supercomputing never did. Every climate model, nuclear physics sim, and rocket trajectory still had thousands of lines of Fortran humming in the background. The world thought Fortran retired, but in reality, it just got quieter like an old raid boss waiting in the shadows.

References:

The quiet comeback

So if Fortran was the fossil language everyone joked about, how the hell did it sneak back onto the main stage?

Two words: math wins.

By the 2010s, workloads were exploding in HPC (high-performance computing), climate science, astrophysics, and later AI training. We needed code that could run insanely fast, scale across cores, and squeeze every ounce of performance from GPUs. Turns out, the old champ was already sitting there, optimized for number crunching since Eisenhower was president.

If you’ve ever imported NumPy, congrats: you’ve touched Fortran. Under the hood, NumPy calls into BLAS and LAPACK, legendary math libraries originally written in Fortran. Same with MATLAB. Same with a bunch of GPU-accelerated scientific codes. All those clean Python wrappers? They’re just friendly interfaces over 50+ years of optimized Fortran routines.

And it’s not just dusty legacy. Communities like Fortran-lang.org have been modernizing the language with features like modules, coarrays (for parallelism), and C/Python interoperability. The syntax is less terrifying than the old punched-card era, and new compilers keep it screaming fast.

Here’s the analogy I use: Fortran is like vinyl records. Everyone wrote it off when CDs and MP3s came along. But when you care about pure quality in its domain, vinyl crushes the competition. Same with Fortran in heavy math, it still slaps.

So while JavaScript frameworks kept multiplying like rabbits, Fortran quietly kept running climate models, nuclear simulations, and particle physics experiments on the world’s fastest supercomputers. And with AI workloads now demanding insane matrix math throughput? Surprise Fortran never left. It just stopped caring about the hype cycle.

References:

Fortran in AI and HPC today

Here’s the funny part: if you’re running AI experiments right now, you’re probably depending on Fortran without realizing it.

Most modern ML stacks are built like an onion of abstractions. At the top, you’ve got your nice, Pythonic interface import torch or import tensorflow. Peel a layer deeper, you hit C/C++. Go deeper still, and guess what’s lurking in the basement? Good old Fortran, crunching matrix multiplications like it’s still the Space Race.

BLAS (Basic Linear Algebra Subprograms) → written in Fortran, still the gold standard for vector/matrix ops.
LAPACK → linear algebra library, Fortran core with decades of optimization.
OpenBLAS and Intel MKL → modern performance-optimized libraries, but heavily derived from Fortran lineage.
NumPy/SciPy → Python wrappers, but a ton of the heavy lifting is still Fortran under the hood.

It’s like building a shiny React app only to realize the backend is an old PHP service nobody talks about. Except in this case, that “old service” is blazingly fast and battle-tested for 60+ years.

And it’s not just math libraries. Supercomputers that run climate simulations, nuclear safety models, or global pandemic spread models? Almost guaranteed there’s Fortran code chugging along somewhere in the stack. In fact, according to Top500.org, many of the fastest supercomputers still compile and run massive Fortran codebases daily.

Modern Fortran isn’t frozen in the past, either. The latest standards (2008, 2018) added parallelism features, interoperability with C and Python, and even coarrays for distributed memory parallel programming. Which basically means you can still squeeze it into modern toolchains without feeling like you’re coding on a typewriter.

Python (NumPy, PyTorch)  
   ↓  
C / C++ (bindings)  
   ↓  
Fortran (BLAS, LAPACK, legacy HPC libs)  
   ↓  
Hardware (GPU/CPU)

References:

Why devs should (or shouldn’t) care

Let’s be real: nobody’s asking you to drop your JavaScript stack and go full Fortran. There aren’t going to be Fortran bootcamps popping up on TikTok anytime soon. So why should you, a modern dev, care about a language old enough to have grandkids?

Here’s the short answer: because it still matters in the background.

If you’re building web apps, you can ignore it. If you’re into AI infra, scientific computing, climate modeling, or physics simulations, then Fortran is like Linux invisible until you need it, and absolutely everywhere once you look.

I once talked to a grad student who inherited a 10,000-line Fortran codebase for a fluid dynamics simulation. He swore it was like fighting a Soulsborne boss: cryptic, punishing, but ultimately rewarding once you learned its attack patterns. By the end, he wasn’t fluent, but he respected it. That’s the vibe: you don’t have to love Fortran, but you better respect it.

And honestly, there’s something humbling about realizing that your shiny Python AI notebook is piggybacking on math routines optimized in the 70s. It’s like when you discover your favorite indie game runs on an engine older than you.

So should you learn it?

If you’re a web dev: nah, don’t bother. Stick with what pays.
If you’re in data science or ML research: know that it exists, because you’ll run into it in NumPy/SciPy.
If you’re in HPC or hardcore simulations: yes, you’ll eventually read or extend some Fortran. It’s like hazing, but with semicolons.

Bottom line: caring about Fortran isn’t about writing it daily. It’s about understanding the stack beneath your tools. Even if you never type DO I = 1, 10, you’ll respect that it’s still carrying workloads Python alone can’t touch.

References:

The future of old code in modern stacks

So where does Fortran go from here? Is it about to take over like Rust memes on Twitter, or will it quietly keep grinding in the background?

Here’s the truth: Fortran will never be mainstream again. You won’t see a YC startup pitching “Fortran-for-startups” or someone building a trendy Fortran web framework. That ship sailed before the internet existed. But in the spaces where raw math performance matters HPC, weather models, particle physics, and AI infrastructureit’s not just surviving, it’s irreplaceable.

In fact, I’ll make a slightly controversial call: Fortran will outlive Swift. Why? Because Swift is tied to Apple’s ecosystem and hype cycles. Fortran is tied to scientific research, billion-dollar supercomputers, and workloads that cannot fail. Which one do you think matters more in the long run?

We’ll probably see more wrappers and bridges rather than people writing raw Fortran. Think: Python devs casually importing a Fortran routine without realizing it. Or C++ engineers calling into Fortran libraries that have been tuned for decades. The language itself won’t “come back” to the mainstream, but its fingerprints will keep showing up everywhere performance is non-negotiable.

And honestly, this story isn’t just about Fortran. It’s about legacy code that refuses to die. COBOL is still running banks. C is still running kernels. Fortran is still running science. The future isn’t about replacing these; it’s about building layers on top of them, keeping them alive in disguise.

So when people ask, “Is Fortran making a comeback?” the real answer is:
It never really left. It just went quiet and now the spotlight swung back because AI and HPC made everyone realize grandpa still benches more weight than the kids.

References:

Conclusion: old code never dies, it respawns

When I first heard whispers about Fortran “coming back,” I rolled my eyes. Then I realized the joke was on me my AI experiments were secretly powered by libraries written in Fortran decades ago. That’s when it clicked: languages don’t really die. They just respawn when you least expect it.

Fortran isn’t here to take your React job. It won’t trend on Hacker News for being “the next big web framework.” But in the domains that actually push hardware to its limits HPC, physics, AI pipelines it’s the quiet backbone nobody talks about. And honestly? That makes it more legendary.

Maybe the lesson isn’t about Fortran at all. Maybe it’s about respecting the stack under your stack the invisible layers carrying your shiny abstractions. Today it’s Fortran. Tomorrow it could be some obscure library you’ve never heard of, written before your parents met.

So here’s my slightly controversial take: Fortran will still matter when half of today’s trendy languages are forgotten. Not because it’s popular, but because it’s too damn good at what it does.

What do you think? Would you ever touch Fortran in 2025 or do you prefer to let grandpa keep carrying your AI stack in peace?