--- url: "https://www.xcademia.com/news/openai-improves-ai-coding-for-cobol-fortran-and-legacy-systems" title: "OpenAI Improves AI Coding for COBOL, Fortran and Legacy Systems" description: "OpenAI reports improved AI coding and COBOL migration results, with new benchmarks for legacy software development across 20 programming languages." publishedAt: "2026-10-21T09:48:51.619+00:00" updatedAt: "2026-10-22T17:02:39.569238+00:00" type: news category: "ai-ml" source_name: OpenAI source_url: "https://openai.com/index/low-resource-programming-languages/ " tags: - "#ArtificialIntelligence" - "#AICoding" - "#LegacyModernization" - "#COBOL" - "#SoftwareEngineering" - "#EnterpriseAI" - "#CodeMigration" - "#OpenAI" --- # OpenAI Improves AI Coding for COBOL, Fortran and Legacy Systems > OpenAI reports major improvements in AI coding and COBOL migration, targeting legacy programming languages that support critical business systems. New evaluations measure software-building ability and behavior-preserving code migration. Source: **OpenAI** · 21 October 2026 **O**penAI has announced improvements in its latest AI models for writing software in low-resource programming languages, including COBOL, Fortran, Visual Basic and OCaml. Published on October 19, 2026, the announcement introduces two evaluations designed to measure how effectively AI models can build software in different languages and migrate existing COBOL programs while preserving their original behavior. The announcement addresses a persistent challenge in enterprise software development. While modern AI coding tools are often used with popular languages such as Python and JavaScript, many organizations continue to depend on older systems written in languages with less publicly available training code and documentation. These systems can be difficult to maintain and modernize. Original developers may have left, documentation may be incomplete, and essential business rules may be embedded in the source code itself. OpenAI says its latest models show substantial improvements across both evaluations, with higher accuracy and lower estimated API costs in the reported tests. ## Why Low-Resource Programming Languages Matter Low-resource programming languages are languages for which AI models have comparatively limited code examples and documentation to learn from. The term does not necessarily mean that a language is rarely used or unimportant. COBOL, for example, remains relevant to financial and business infrastructure. OpenAI cites its use in banking systems, in-person credit card transactions and ATM transactions. Fortran continues to support scientific computing, including weather forecasting and nuclear record safety analysis. For organizations relying on these systems, rewriting software is not simply a matter of translating one programming language into another. A successful modernization effort must preserve the original program's behavior, including its edge cases and business-specific rules. AI could help reduce some of the effort involved, but its output must still be validated against the requirements of the system being changed. ![difficult-to-modernize](https://0a515t3ure77wbvx.public.blob.vercel-storage.com/articles/1792573379066-difficult-to-modernize.webp) ## OpenAI Introduces Two Evaluations for AI Coding OpenAI developed two evaluations to examine complementary aspects of software engineering: building a functional application in different programming languages and migrating existing code without changing its behavior. ### 1. MultiLangBench: Building a SQLite-Compatible Database Engine The first evaluation, MultiLangBench, tests whether an AI model can build a SQLite-compatible database engine from scratch in 20 programming languages. The task requires more than generating isolated code snippets. A model must organize a codebase, manage state, handle errors, implement features and preserve existing functionality throughout an extended coding session. The evaluation adapts tests from SQLite's existing test suite. Programs receive an initial database and a SQL query, then produce a modified database. The result is checked against a reference SQLite implementation to determine whether the expected database contents were produced. This approach gives the evaluation a common testing method across different programming languages. OpenAI reports the following results at maximum reasoning effort: Evaluation measure GPT-5.6 Sol GPT-6 Astra Average test pass rate across 20 languages 26.8% 87.4% COBOL test pass rate 10.9% 72.1% OCaml test pass rate 25.6% 85.8% Fortran test pass rate 21.4% 83.5% Visual Basic test pass rate 27.5% 89.4% Source: OpenAI's MultiLangBench evaluation. These are company-reported benchmark results, not independent production measurements. The results suggest that the newer model performs substantially better on the tested software-building tasks. OpenAI says GPT-6 Astra scored above 83% in 19 of the 20 languages tested, with COBOL remaining the most challenging at 72%. OpenAI also reports results for GPT-6 Luna, a lower-cost option. At maximum reasoning effort, Luna achieved an average pass rate of 40.3%, compared with 26.8% for GPT-5.6 Sol. The company estimates an average API cost of $0.77 per sample for Luna, compared with $3.48 for GPT-5.6 Sol, approximately 78% lower. These findings matter because the evaluation measures the ability to build and test a multi-component software system rather than merely generate code that looks correct. OpenAI has also released the MultiLangBench evaluation setup and test suite on GitHub, allowing developers to inspect the tests and examine results across individual languages. ![ai-software-engineering](https://0a515t3ure77wbvx.public.blob.vercel-storage.com/articles/1792574881587-ai-software-engineering.webp) ### 2. COBOL Migration: Preserving Existing Program Behavior The second evaluation focuses on one of the most challenging aspects of legacy modernization: moving an existing COBOL program to another programming language without changing what it does. OpenAI tests migration to C++, Java, Kotlin, Python or Rust. The evaluation uses hidden tests that require byte-for-byte parity on observable outputs. A migration is considered successful only when all tests pass. This is important because two programs can look logically similar yet produce different results when handling rounding, missing records or other edge cases. Consider a financial calculation in a legacy application. COBOL fixed-point arithmetic can discard excess decimal digits unless rounding is explicitly requested. If a rewritten program rounds those values differently, it may execute without errors while producing different financial results. The software might appear to work correctly while silently changing an important business rule. OpenAI reports these results for its COBOL migration evaluation: Model and setting Reported accuracy GPT-5.6 Sol at low reasoning effort 5.4% GPT-6.1 Sol at low reasoning effort 86.6% GPT-6.1 Sol at higher reasoning effort 97.9% Source: OpenAI's COBOL migration evaluation. Results reflect the company's specific test suite and evaluation conditions. OpenAI also reports that GPT-6.1 Sol achieved the 86.6% result at low reasoning effort while costing 39% less than GPT-5.6 Sol in the comparison. At higher reasoning effort, reported accuracy reached 97.9%, bringing performance close to the evaluation's ceiling. These results indicate progress in behavior-preserving code migration under the conditions tested. However, a high benchmark score does not establish that every real-world migration will succeed. Production applications can contain undocumented dependencies, unusual inputs and operational requirements that are not fully represented in a benchmark. ![COBOL-migration](https://0a515t3ure77wbvx.public.blob.vercel-storage.com/articles/1792574984793-cobol-migration.webp) ## What the Announcement Means for Enterprise Developers OpenAI's results address a practical issue for organizations maintaining established software: AI coding systems need to work reliably across more than the languages most represented in public code repositories. The company says its work has been informed by feedback from developers and enterprise customers who reported that coding models often struggle with these languages. Its stated goal is to improve model performance across unfamiliar repositories, build tools, testing and debugging workflows. For engineering teams, several potential benefits deserve attention. **Reduced barriers to legacy maintenance** AI assistance could help developers understand unfamiliar code, investigate bugs and make targeted changes in older systems. This may be especially useful when original documentation is incomplete or the engineers who built the software are no longer available. However, teams still need people who understand the application's purpose and can verify whether proposed changes preserve its requirements. **More options for modernization** Organizations may be able to evaluate migration approaches earlier in the modernization process. AI-generated translations can provide a starting point for comparison, testing and code review. That does not mean every application should be rewritten. Some systems may be safer or more economical to maintain in their current language, depending on their dependencies, operational requirements and business constraints. **Better visibility into language-specific weaknesses** Publishing MultiLangBench gives developers a way to inspect the evaluation and identify where model performance is strong or weak. Independent testing is important because aggregate results can hide differences between programming languages and task types. Teams should assess the languages, libraries and workloads relevant to their own environments. ## What Enterprises Should Validate Before Using AI-Generated Code The announcement demonstrates progress on defined coding evaluations, but enterprise adoption requires more than benchmark accuracy. Organizations considering AI-assisted development or migration should establish a verification process appropriate to the system's risk. - Document expected behavior: Record business rules, input constraints, outputs and edge cases before changing code. - Run regression tests: Compare the new implementation with the original using representative and boundary-case inputs. - Review numerical behavior: Check rounding, precision, date handling and missing-record behavior where relevant. - Inspect dependencies: Verify that the target application uses supported libraries and integrates correctly with surrounding systems. - Apply security testing: Review access controls, input validation, data handling and other security requirements. - Keep human approval: Require qualified engineers to review consequential changes before production deployment. These are editorial recommendations for adopting AI-assisted software engineering, not additional capabilities announced by OpenAI. The company did not establish through the published benchmark results that all generated code is secure, that migrations will be successful in every production environment, or that organizations can eliminate expert review. ## The Broader Industry Context The announcement highlights a broader industry shift toward evaluating AI coding systems on complete engineering tasks, rather than focusing only on code completion or short programming exercises. For enterprises, this could mean more opportunities to investigate legacy modernization, particularly where older software is expensive to maintain. Yet success will depend on whether AI-generated changes preserve business behavior and meet real operational requirements. A useful distinction is between producing code that passes a benchmark and delivering a maintainable, secure production system. The former is measurable within a defined evaluation. The latter also depends on integration, testing, security, governance and human expertise. OpenAI's release of MultiLangBench supports further examination of its cross-language results. Its separate COBOL migration evaluation offers evidence of progress on behavior preservation, although the reported scores should be interpreted within the company's testing methodology. The next important step for organizations is to assess these capabilities against their own codebases, constraints and acceptance criteria. ## Conclusion OpenAI's October 19 announcement reports significant improvements in AI-assisted software development across low-resource programming languages, including COBOL, Fortran, OCaml and Visual Basic. Its two evaluations address distinct challenges: building a SQLite-compatible database engine across 20 languages and migrating COBOL programs while preserving their observable behavior. The reported results show substantial gains over the compared models, alongside lower estimated costs in selected tests. For enterprise teams, the development offers a reason to evaluate AI-assisted legacy maintenance and modernization. It is not a substitute for comprehensive testing, security review or expert oversight. The practical value will ultimately depend on whether these improvements translate into reliable results on real applications, with their unique business rules, dependencies and operational risks. ## Original source https://openai.com/index/low-resource-programming-languages/ ## Tags `#ArtificialIntelligence` · `#AICoding` · `#LegacyModernization` · `#COBOL` · `#SoftwareEngineering` · `#EnterpriseAI` · `#CodeMigration` · `#OpenAI` --- ## About this content This Markdown news article is the citation-grade twin of [OpenAI Improves AI Coding for COBOL, Fortran and Legacy Systems](https://www.xcademia.com/news/openai-improves-ai-coding-for-cobol-fortran-and-legacy-systems). It is published by **Xcademia** (UK Companies House 12322710) and is available for AI search engines and large language models to index, summarise, and cite. When citing or quoting, please attribute *Xcademia* and link back to the source URL above. - Source: https://www.xcademia.com/news/openai-improves-ai-coding-for-cobol-fortran-and-legacy-systems - Publisher: Xcademia, https://www.xcademia.com - Catalogue index: https://www.xcademia.com/llms-full.txt