Google Says Its AI Rebuilt a 40-Year-Old Ocean Model in 59 Minutes

Using Gemini 4 Argon, Google says it transformed a 174,774-line scientific codebase into modern Rust, uncovered six longstanding bugs and made simulations nearly twice as fast. The experiment offers a glimpse of how AI could reshape scientific computing.

Some of the world's most important scientific software is older than many of the researchers now working with it. Written decades ago, these programs still help scientists understand ocean currents, model coastal flooding and study the physical systems shaping our planet.

Now, Google says an AI agent has completed a task that traditionally could take engineering teams months or even years.

In a technical report published on November 3, Google described how its Gemini 4 Argon model, operating through its Antigravity development platform, migrated the core of a 40-year-old ocean simulation system from Fortran into Rust in just 59 minutes.

The project involved 174,774 lines of code spread across 264 files.

The reported results go beyond translating one programming language into another. Google says the AI identified six longstanding bugs, reduced memory usage by 54% and improved simulation performance by 1.88 times.

Why Scientists Still Depend on 1980s Software

The software at the center of the experiment is FVCOM, short for Finite-Volume Community Ocean Model.

It is designed to simulate coastal ocean circulation and has applications in understanding complex marine environments.

Despite advances in computing, scientific institutions continue to depend on older software written in languages such as Fortran.

There is a reason for that.

These programs often contain decades of scientific work. Their mathematical models have been tested, calibrated and refined against observations from satellites, research vessels and ocean monitoring systems.

Replacing them is not simply a matter of rewriting code.

A small mathematical difference can affect simulation results, potentially undermining years of research.

The challenge is not just making old software run faster. It is modernizing it without losing the science that makes it valuable.

What Gemini Actually Did

Google did not simply ask an AI chatbot to translate a collection of files.

Instead, it used Antigravity as an autonomous engineering environment, allowing Gemini 4 Argon to inspect the codebase, operate a terminal, compile software, run tests and correct errors.

The process involved three stages.

First, understanding the original software

The agent spent 11 minutes compiling the original Fortran program and recording its performance and numerical outputs.

It then examined all 264 files, mapped dependencies and created an architectural plan before beginning the rewrite.

Then, rebuilding the system

Over the next 45 minutes, the agent created 13 Rust modules and repeatedly tested the new implementation.

When a test failed, it examined the error, modified the relevant code and ran the tests again.

Finally, checking the results

The new implementation was compared against the original software using 100 randomized simulation tests.

Google reports that all 100 runs matched the original numerical results to 12 decimal places.

The test suite also achieved 96.8% branch coverage.

Six Bugs That Had Survived for Years

One of the more interesting findings was what happened during the migration itself.

Google says the AI uncovered six genuine bugs in the original Fortran and C implementation.

They included integer overflows, unsafe memory access, uninitialized values and an unguarded mathematical operation involving seawater density.

These were not necessarily problems that had recently appeared. They had existed in software that had been maintained and used over many years.

The discovery highlights an important advantage of examining old software through a different technical architecture.

Moving code into Rust forced the system to confront memory-safety rules that older Fortran and C implementations do not enforce in the same way.

The Performance Numbers

The final benchmark showed a substantial improvement in the specific test environment used by Google.

Measurement| Original| New Rust version Runtime| 883 ms| 469 ms Peak memory| 11.84 MB| 5.48 MB Relative speed| 1.00x| 1.88x

Google attributes much of the improvement to eliminating repeated memory allocations inside computationally intensive simulation loops and applying compiler optimization techniques.

The result was a simulation that completed in almost half the original time while using significantly less memory.

These figures are Google's reported benchmarks for this particular workload, not a guarantee that every legacy scientific application would see similar improvements.

Why This Matters Beyond Google

The experiment points to a much larger problem in science and engineering.

Across universities, research laboratories and government institutions, important software is becoming increasingly difficult to maintain.

The people who originally developed these systems may have retired, while the knowledge needed to understand their architecture is often scattered across decades of documentation and research papers.

Modernizing such software manually can be expensive, risky and time-consuming.

AI agents could change that equation.

Rather than merely generating individual functions, they can potentially examine entire repositories, understand relationships between files, execute software, identify errors and verify whether a replacement behaves like the original.

That could make previously neglected scientific tools easier to maintain and improve.

The Limits of the Breakthrough

There is an important distinction between an impressive engineering demonstration and independently verified scientific progress.

The results were published by Google, the company behind the model and development platform. The reported benchmarks and migration results should therefore be understood as company-reported findings, not as an independent evaluation of every aspect of the project.

The experiment also involved a specific codebase, carefully defined requirements and an automated testing environment.

It does not establish that AI can safely rewrite every decades-old scientific system without human supervision.

Scientific validation, independent review and long-term testing remain essential, particularly when software is used in environmental forecasting or other high-impact research.

A Different Future for Scientific Software

The most interesting part of this experiment may not be the 59-minute figure.

It is the possibility that AI could help preserve scientific knowledge embedded in software that would otherwise become increasingly difficult to maintain.

If similar approaches prove reliable across more projects, researchers may spend less time struggling with aging codebases and more time investigating the problems those programs were originally designed to solve.

For now, Google's experiment is a promising demonstration rather than proof of a universal solution.

But it raises a question that software engineers and scientists will increasingly have to consider:

What if the next major advance in science comes not from writing entirely new software, but from finally making decades of existing scientific knowledge usable again?

Reporting by Gulf Latin Desk, based on Google's published technical research.