OpenAI boosts COBOL/Fortran/VB coding and ships two self-built evals for low-resource languages
Core Highlights
OpenAI announced that its latest models show significant improvement on "low-resource programming languages" such as COBOL, Fortran and Visual Basic, and introduced two in-house evaluations to quantify the progress. This fills a long-neglected gap in AI coding ability: the old languages that still run much of the world's critical infrastructure.
What Happened
Large models usually show off on mainstream languages like Python and JavaScript. Yet the core systems of banks, insurers and governments run enormous quantities of COBOL and Fortran code. Pushing capability toward these languages goes straight at the enterprise scenarios that are most valuable and most short-staffed. By building two dedicated benchmarks, OpenAI signals that it wants to prove in measurable terms that "old languages can be written well," rather than saying so casually.
Technical Details
"Low-resource" refers to languages with scarce training corpora, small communities and weak modern toolchain support. For a model to improve on such languages, the usual recipe combines synthetic data, cross-lingual transfer and specialized evaluation sets. COBOL in particular is verbose and domain-specific, with constructs that have no close analogue in modern code; Fortran remains entrenched in scientific computing; Visual Basic persists in line-of-business Windows applications. Each demands its own handling. The two self-built evaluations matter because they give the claim a reproducible basis instead of relying on anecdote.
Comparison With Peers
Most coding models default to popular languages, and support for legacy languages is a widespread weak spot. OpenAI's deliberate investment here is both differentiation and a fit with its strategy of going deep into real enterprise IT — where the genuine pain is often not writing new features but maintaining systems decades old.
Industry Impact and Use Cases
For industriesheavy on legacy systems — finance, government, industrial manufacturing — this is tangible good news. Using AI to help read, maintain and refactor old code eases the human-resource crisis created as engineers who understand COBOL retire. For developers, it widens the boundary of what a coding assistant can do.
Further Context
The economic argument is hard to overstate. Estimates of COBOL code still in production run into billions of lines, powering payment processing, policy administration and government records. Much of the documentation is gone and the original authors have retired, so institutions face a dilemma: rewriting is expensive and risky, while leaving systems untouched means accumulating technical debt and dependence on a shrinking pool of specialists. AI assistance that can reliably explain, test and incrementally modernize such code addresses both horns of that dilemma.
There are realistic limits, however. Fluency is not the same as correctness in a regulated environment, where a subtle change in a calculation can have legal consequences. Legacy systems are often entangled with decades of implicit business rules that no benchmark captures. The sensible posture is augmentation rather than replacement: let the model explain unfamiliar code, draft tests and suggest migrations, while humans retain authority over changes. Two custom evaluations are a start, but buyers should demand evidence on their own codebases before trusting the tool with production logic. If that bar is met, the payoff is enormous — a way to keep critical systems maintainable without a risky big-bang rewrite.
Additional Notes
The significance of benchmarks here deserves a closer look. Most public coding evaluations draw heavily on Python, JavaScript and a handful of mainstream languages, so a model can appear broadly capable while being untested on the languages that matter to legacy-heavy institutions. Building two in-house evaluations is an admission that existing benchmarks did not capture the dimension OpenAI wanted to improve. That is a useful corrective, though the industry should treat self-authored benchmarks with the same healthy skepticism applied to any vendor metric: the real proof is independent reproduction on real codebases.
There is also a generational dimension. COBOL and Fortran systems are often documented sparsely, with business logic embedded in decades of accumulated patches. A model that can read and explain such code lowers the cost of onboarding engineers who did not grow up with it. It can also generate tests around behavior that was previously only assumed, which is often the first safe step before any refactor. In that sense, the value is not only writing new COBOL but making old COBOL understandable.
For procurement teams, the prudent approach is a controlled pilot. Pick a bounded module, ask the model to document it, then to propose tests, and only later to suggest changes — with human review at each stage. Measure time saved and defect rates rather than fluency. If the results hold, the technology offers a way to keep vital systems alive while gradually reducing dependence on a retiring generation of specialists. That is a concrete, valuable outcome, well removed from the flashier claims that usually surround model releases.
Closing Note
The broader payoff is institutional continuity. Systems that have run reliably for decades represent accumulated business knowledge, and discarding them wholesale is rarely affordable. Giving engineers tools that make that knowledge legible — explaining code, surfacing implicit rules, drafting regression tests — extends the life of critical systems while a new generation comes up to speed. That quiet, unglamorous work may be the most valuable thing AI coding assistance has to offer legacy-heavy industries.