Moving 250k lines of legacy weather simulation code to GPUs

Imagine staring at a quarter-million lines of Fortran or C++ written by a scientist who retired in 2004 and trying to figure out how to make it run on an H100 without the whole thing exploding. That's the baseline for most legacy weather models. I've been looking into how AI can handle this kind of massive porting job, and it turns out that if you don't just blindly copy-paste from a chat window, you can actually shave months off the deployment timeline.

The real struggle with legacy scientific code isn't just the syntax; it's the implicit memory dependencies and the "magic numbers" buried in the physics kernels. If you try to port this manually, you're basically playing a high-stakes game of Minesweeper. Using an LLM agent to map out the data flow first is the only way to stay sane.

The Actual Workflow for Massive Porting

You can't just feed 250k lines into a prompt—the context window will choke or the AI will start hallucinating its own version of atmospheric pressure. The only practical tutorial for this is a "chunk and verify" approach.

1. Dependency Mapping: Use a script to generate a call graph of the entire codebase. Feed the AI the header files and the call graph so it understands the hierarchy before it touches a single line of logic.
2. Kernel Identification: Identify the "hot" loops—the parts of the weather sim that actually do the heavy lifting. These are your primary targets for CUDA or OpenACC.
3. Iterative Translation: Instead of porting files, port specific computational kernels.

For example, when converting a legacy loop to a GPU-accelerated version, the prompt engineering needs to be hyper-specific about memory alignment to avoid the dreaded coalescing issues.

// Legacy CPU loop
for (int i = 0; i < grid_size; i++) {
    pressure[i] = compute_pressure(temp[i], humidity[i]);
}

// AI-suggested CUDA kernel (simplified)
__global__ void compute_pressure_kernel(float* pressure, float* temp, float* humidity, int grid_size) {
    int i = blockIdx.x * blockDim.x + threadIdx.x;
    if (i < grid_size) {
        pressure[i] = compute_pressure(temp[i], humidity[i]);
    }
}

The Reality Check

• Accuracy: The AI is great at the boilerplate but terrible at floating-point precision errors. You'll spend 20% of your time porting and 80% of your time wondering why the simulated rain is falling upward.
• Speedup: You can get a massive throughput increase, but the bottleneck usually shifts from the compute to the PCIe bus because the legacy data structures are rarely GPU-friendly.
• Maintenance: Now you have 250k lines of code that "mostly" work, but only the AI knows why it chose a specific shared memory tiling strategy.

This isn't a "push a button and get a GPU app" situation. It's more like using a very fast, slightly drunk assistant to do the grunt work of a deep dive into ancient code. If you're doing a real-world deployment of this scale, treat the AI as a translation layer, not an architect.