Modernize Your Legacy Code: COBOL, FORTRAN, PASCAL, BASIC, C

The percentage of translation is near 100%.  In terms of lines of code, where an application represents 5 million lines, there can be a few dozen places where some pre-translation updates are required.  These updates can usually be taken back to the OpenVMS environment, but a few may remain.  We have a mechanism to account for those issues.  What is more important is that there are no fixes required, post-translation.

The translation is done on Linux and can take about 15-20 minutes on a small Linux instance.

Immediately after the translation is performed, the remedied code is compiled on Linux using a compiler listed above.  For instance, NetCOBOL will compile the 5 million lines of remedied code in about 15 minutes.  These Linux-based compilers are really fast.

VX/COBOL is a comprehensive solution designed to migrate legacy COBOL applications from mainframe environments to modern, flexible Linux-based systems. It allows businesses to retain their valuable, time-tested business logic without needing to rewrite code from scratch.

This approach helps organizations significantly reduce the high operational costs associated with mainframe hardware and software licensing. By moving to a Linux environment, companies can modernize their IT infrastructure, improve performance, and ensure their critical applications are future-proof. Many businesses, like Sprint T-Mobile, have successfully leveraged similar migration strategies. To discover how we can help you, please contact us.

VX/COBOL includes a powerful suite of tools to ensure a seamless migration and high performance on Linux. The key features are:

• High-Performance Compiler: Supports various COBOL dialects, which minimizes the need for code changes during recompilation.
• Mainframe Emulation: A robust runtime environment that emulates essential mainframe services like CICS, IMS, and JCL, allowing applications to run on Linux without modification.
• Data Migration Utilities: Tools to convert mainframe data formats such as VSAM and sequential files into Linux-compatible formats.
• Integrated Debugging: A complete set of tools for testing and debugging to ensure the migrated application is functionally identical to its mainframe predecessor.

For more details on how these features can benefit your organization, contact us.

The VX/COBOL runtime environment is specifically designed to bridge the gap between mainframe and Linux systems. It works by emulating the core services and APIs that COBOL applications rely on in a mainframe environment, such as CICS for transaction processing, IMS for database management, and JCL for batch job control.

This emulation layer allows your existing COBOL applications to execute on Linux without requiring any changes to the source code that interacts with these services. It effectively tricks the application into thinking it's still running on the mainframe, ensuring a smooth transition and preserving years of investment in your business logic. Companies like Allianz have found great success with this kind of modernization. If you have questions about your specific dependencies, contact us to discuss them.

The migration process with VX/COBOL is a structured, multi-phase approach designed to minimize risk and ensure a successful transition. The typical stages are:

1. Assessment: We start by thoroughly analyzing your existing COBOL application to understand its architecture, dependencies, and complexities.
2. Planning: A detailed migration plan is created, outlining timelines, resource requirements, and a comprehensive testing strategy.
3. Execution: This phase involves recompiling the COBOL source code, migrating all necessary data from mainframe formats to Linux-compatible ones, and deploying the application in the new environment.
4. Testing: Rigorous testing is conducted to verify that the migrated application meets all functional and performance benchmarks, ensuring it behaves exactly as it did on the mainframe.
5. Deployment: The final step is rolling out the application into production and decommissioning the legacy mainframe system.

To get a personalized plan for your migration, contact us today.

Migrating COBOL applications to a Linux environment with VX/COBOL offers significant strategic advantages for any organization.

• Major Cost Reduction: The most immediate benefit is the elimination of expensive mainframe hardware maintenance and software licensing fees.
• Infrastructure Modernization: It allows you to move to a flexible, scalable, and modern platform that easily integrates with cloud and other modern technologies.
• Improved Performance: You can leverage the power of modern commodity hardware and the efficiency of the Linux operating system for better application performance.
• Future-Proofing: By moving to a widely supported and actively developed platform, you ensure the long-term viability and maintainability of your critical business applications.

Organizations like Amprion GmbH have realized these benefits. Find out what you can achieve by contacting us.

No, one of the primary advantages of VX/COBOL is that it minimizes the need for code modification. The solution is built around a "recompile and run" philosophy. Its high-performance compiler supports various COBOL dialects, and the runtime environment emulates mainframe services, which means your existing business logic can be preserved.

The goal is to recompile the source code on the Linux platform with minimal to no changes, ensuring that the core functionality of the application remains intact. This dramatically reduces the risk, time, and cost associated with a full rewrite. To see how this applies to your codebase, contact us for an assessment.

VX/COBOL includes a set of specialized data migration tools designed to handle the conversion of mainframe-specific data formats. These utilities can read data from formats like VSAM (Virtual Storage Access Method) and sequential files and convert them into modern, Linux-compatible formats, such as indexed files or relational database tables.

This ensures that all your critical business data is migrated accurately and efficiently, maintaining data integrity throughout the process. The migrated application can then access this data seamlessly in the new Linux environment. This approach has been proven in projects for companies like BNY Mellon. For specific questions about your data, please contact us.

VX/COBOL provides a comprehensive suite of debugging and testing tools to ensure the functional equivalence of your application after migration. These tools are designed to help developers validate that the application behaves exactly the same on Linux as it did on the mainframe.

The testing phase is critical to the success of any migration project. With VX/COBOL, you can conduct thorough testing to identify and resolve any discrepancies, ensuring that the application meets all functional requirements and performance expectations before going live. This rigorous process is how we ensure success for clients like Amco. To learn more about our testing methodologies, contact us.

VX/COBOL will transform the embedded SQL statements from Rdb to PostgreSQL / Oracle.  The changes are few, but significant.  At the end of the transformation, the COBOL application on Linux will access PostgreSQL/Oracle instead of Rdb. Fujitsu (makers of NetCOBOL ) have a COBOL preprocessor available in the r enterprise version which supports PostgreSQL.

‍

VX/PASCAL is an automated transpiler that converts OpenVMS Pascal to ANSI-compliant C++ for execution on Linux. It fully supports VMS-specific extensions, CDD data structures, and RMS file handling ensuring 100% compatibility. To explore VX/PASCAL for your migration, contact us.

VX/PASCAL supports VMS stack operations, Common Data Dictionary (CDD) integration, RMS file handling, VMS API mapping, and optimized string operations using STR$CONCAT and STR$COPY.

VX/PASCAL automates migration in four steps: source code analysis, transpile to C++, compile with GNU C++, and validate with automated testing to ensure identical behavior.

Yes, VX/PASCAL allows continuous development without code freeze. Teams can continue enhancing VMS Pascal applications while changes remain synchronized between Pascal and C++ versions.

VX/PASCAL provides 500+ customizable options including VMS API mapping, variable naming conventions, code formatting, and error code translation to meet enterprise standards.

VX/PASCAL automatically handles VMS stack argument tracking (PRESENT/NOT PRESENT) that Linux doesn't support, preventing stack corruption by generating equivalent C++ code that maintains identical behavior.

VX/PASCAL has successfully translated over 3 million lines of Pascal code with 100% automation, bug-for-bug compatibility, and zero code freeze. Organizations eliminate vendor lock-in and reduce infrastructure costs. Contact us to discuss your requirements.

VX/FORTRAN is a powerful automated migration tool that translates OpenVMS FORTRAN to ANSI-compliant FORTRAN (Intel Fortran) for execution on Linux. It extends Fortran Partner (FPT) with VMS-specific features, standards adherence, and performance optimizations.

The tool is specifically designed for aerospace, defense, and high-tech industries to ensure complete, error-free Fortran migration while preserving decades of software investment. To learn more about how VX/FORTRAN can modernize your legacy systems, contact our migration experts.

No, VX/FORTRAN provides 100% automated migration without requiring manual code modifications.

The migration follows four automated steps: source code analysis to identify VMS-specific extensions and dependencies, transpilation to ANSI-standard Fortran, compilation with Intel Fortran optimization, and validation through automated testing to verify identical execution behavior.

Yes, VX/FORTRAN supports zero code freeze, allowing you to continue development on VMS while migrating to Linux. This parallel approach ensures business continuity throughout the modernization process.

Organizations like Amprion GmbH have successfully used this approach for large-scale FORTRAN migrations involving millions of lines of code.

VX/FORTRAN performs advanced optimizations including loop unrolling, inline expansion, and memory access optimizations that can speed up execution time by up to 40%.

VX/FORTRAN automatically converts Pro*Fortran SQL statements to external C functions, ensuring seamless database integration on the target Linux platform without manual intervention.

VX/FORTRAN includes comprehensive testing tools that support record/replay execution, trace logs, and QA compliance. The tool automatically detects and fixes errors, improving code quality and maintainability by identifying issues like missing subroutine declarations, inconsistent argument types, and unsafe conversions.

Companies like BNY Mellon have leveraged similar automated migration capabilities for critical financial systems. For detailed information about our testing methodologies and quality assurance processes, contact our team.

VX/C is Sector7's automated tool that converts VMS/OpenVMS C source code into portable, POSIX-compliant ANSI C. It identifies, flags, and corrects VMS-specific issues to ensure your code runs seamlessly on Linux environments.

The tool provides fully automated source code conversion, works with existing Makefiles and build systems, and handles VMS-specific syntax and dependencies. For organizations looking to modernize their legacy systems, contact us to discuss your migration requirements.

VX/C identifies and resolves over 15 categories of VMS-specific issues including addressing constants, variant struct/union usage, missing function arguments, VMS-specific compiler calls, and POSIX type incompatibilities.

VX/C automatically handles VMS-specific include file references, logical name includes, and case sensitivity issues in include paths, ensuring proper POSIX compliance in the migrated code.

VX/C functions like a C compiler, parsing source files and generating formatted reports, fix scripts, and POSIX-compliant source code through a simple command-line interface.

VX/C seamlessly integrates with existing Makefiles and build systems, providing configuration file support for default options. It generates SED scripts for automated code fixes that can be easily applied to your source code.

Companies like DuPont have successfully used similar migration tools to modernize their legacy C applications while maintaining their existing development workflows.

Yes, VX/C automatically corrects missing function arguments, undefined return types, and inconsistent function naming cases. It converts VMS-specific function calls to their POSIX-compliant equivalents and fixes typecasting issues on assignment operations.

VX/C delivers fully automated migration that reduces manual effort and ensures consistent code output across large codebases. It supports continuous integration workflows and has been proven effective in high-complexity migrations.

Organizations achieve seamless portability from VMS/OpenVMS to Linux environments while maintaining code functionality. Companies like Honeywell have leveraged similar automated tools for successful large-scale migrations.

To learn more about how VX/C can accelerate your migration project, contact our migration experts.

VX/BASIC is a full-featured OpenVMS BASIC to ANSI C transpiler that enables legacy BASIC applications to run natively on Linux. It provides 100% conversion of VMS BASIC syntax to working C code while maintaining the original structure, variable names, and comments for easy maintenance.

For organizations ready to modernize their legacy systems, contact us to discuss your specific migration requirements.

VX/BASIC supports all VMS BASIC data types including INTEGER, BYTE, WORD, LONG, DOUBLE, and STRING. The only exceptions are GFLOAT and HFLOAT, which are automatically converted to DOUBLE for compatibility.

VX/BASIC preserves all VMS error codes and handling mechanisms, ensuring programs behave identically to their OpenVMS versions with the same error numbers and responses.

VX/BASIC supports all standard VMS BASIC I/O operations including PRINT, INPUT, and file operations like OPEN FOR INPUT, converting them to equivalent ANSI C functions.

VX/BASIC supports over 900+ VMS system service calls, providing comprehensive integration with VMS functionality including RMS file handling and other system services.

VX/BASIC maintains the original BASIC source code structure while generating optimized C code, allowing developers to continue working with familiar BASIC syntax. The transpiled C code retains the original program flow and variable names, making debugging and maintenance much easier than completely rewritten applications.

VX/BASIC delivers 100% compatibility with VMS BASIC while providing seamless portability to Linux. Organizations retain their valuable software investments while gaining modern infrastructure benefits including reduced hardware costs, improved performance, and enhanced scalability.

Companies like HH Gregg have successfully migrated millions of lines of legacy code using similar approaches. The generated ANSI C code ensures long-term portability and future-proofing for legacy applications.

Ready to explore migration options for your BASIC applications? Contact us to discuss your specific requirements.

VX/C takes OpenVMS/VAX-C and DEC C source and produces portable, POSIX-compliant ANSI C. It identifies, flags, and corrects VMS-specific issues so the generated code targets Linux and other POSIX/UNIX platforms such as macOS.

VX/C works like a C compiler. You run the vxcpp command with a list of switches (for example --include=, --vms-api=lower, --output=) and one or more C source files. It also reads mapping files (--hmapfile=, --vararg_file=) so common option sets and header remaps do not have to be retyped on every run.

VX/C covers 14 feature-coded categories, including addressing constants and strings, variant struct and union usage, union-to-union assignment, several #include problems (text-library includes, logical-name references, case sensitivity), missing function arguments, type mismatches, inconsistent function-naming cases, VMS-specific compiler calls such as vax$errno, incompatible POSIX type usage, undefined return types, and left-hand-side typecasting.

Both. It rewrites the source into POSIX-compliant ANSI C and marks every edit inline with a traceable /*S7-nnn*/ annotation (for example /*S7-041*/ where it padded a system-service call's arguments), and it writes diagnostics for anything it cannot handle to standard error.

Every transformation is tagged in the output with a /*S7-nnn*/ comment that identifies the rule applied, so a reviewer can diff the migrated source against the original and see exactly what the tool did and why. The annotations can be suppressed with --no-s7-tags when they are no longer needed.

It addresses #include directives that pull from a text library without delimiters, #include references via VMS logical names, and case-sensitivity differences in #include paths. It also remaps VMS header names to their POSIX equivalents (for example stat.h to sys/stat.h, in.h to netinet/in.h) using a built-in table plus any user-supplied maps.

Yes. It works with existing Makefiles and build systems and supports continuous-integration workflows. It is typically driven by a batch script that runs vxcpp over a source tree, using --copy= for directory-tree mode, and then compiles the transformed output.

VX/C produces code for Linux and other POSIX/UNIX platforms such as macOS. It ships target personalities that load the correct predefined macros for each host (GCC on Linux, Apple LLVM/clang on macOS). There is no Windows target.

It translates VMS and OpenVMS BASIC into ANSI C source and then compiles that C. C is used as an intermediate language, which is what gives the output long-term portability and lets it build, run, and be debugged directly on modern systems with standard tools.

VX/BASIC converts OpenVMS BASIC into C that compiles and runs on Linux and Windows, while still allowing the application to be maintained in its original OpenVMS BASIC form and re-translated on each release.

All VMS and OpenVMS BASIC data types are supported. Integer types map to fixed-width C types (BYTE to int8_t, WORD to int16_t, LONG to int32_t, QUAD to int64_t), SINGLE and DOUBLE map to float and double, DECIMAL maps to a packed decimal type, and STRING maps to a VMS string descriptor. GFLOAT and HFLOAT are converted to double.

Yes. VX/BASIC keeps both dynamic and fixed-length string handling and uses VMS string descriptors for STRING data, so migrated code stays compatible with VMS BASIC string memory management.

VX/BASIC preserves VMS error codes and the ON ERROR handling model, so programs behave the same as they did on OpenVMS, including RMS errors such as the file-not-found condition. Return-value checks on system routines are backed by the VX/RT runtime libraries, and ERR, ERL, ERT$, RMSSTATUS, and VMSSTATUS are all available for introspection.

VX/BASIC fully translates RECORD and MAP declarations into C. A RECORD becomes a typedef'd struct, a VARIANT becomes a union with one struct per CASE, and several MAP declarations that name the same storage become parallel structs bound to one backing block, preserving the exact VAX BASIC byte layout.

All VMS BASIC statements are supported, including IF...THEN, FOR...NEXT, WHILE, SELECT CASE, GOTO, and ON ERROR GOTO. Terminal I/O such as PRINT, INPUT, and LINPUT is covered, and RMS file I/O supports sequential, relative, indexed, and virtual organizations.

The one documented exclusion is the graphics command family, which is recognised but not translated. GFLOAT and HFLOAT are converted to double rather than preserved exactly (HFLOAT loses precision), and a few OpenVMS-specific options such as OPTION ANGLE are out of scope. Everything else in the core language is supported.

VX/COBOL automatically converts VMS and OpenVMS COBOL to ANSI-compliant COBOL so the application runs on x86 Linux with no manual code changes. The converted code targets the Fujitsu NetCOBOL and Micro Focus COBOL compilers, and the original COBOL logic and structure are preserved.

No. VX/COBOL is a source-to-source translator that does the conversion automatically, so teams do not rewrite their COBOL by hand. It reads OpenVMS COBOL and emits standard ANSI COBOL that Fujitsu NetCOBOL or Micro Focus then compiles on Linux.

VMS and OpenVMS can initialize a pointer by reference, which ANSI COBOL does not allow. VX/COBOL changes the initialization to a null value and generates a MOVE FUNCTION ADDR statement in an init section, so the pointer is set up correctly in the PROCEDURE DIVISION without any manual editing.

VX/COBOL replaces GIVING with RETURNING, converts each OMITTED argument to BY VALUE 0, and for known item-list system services renames the callee to its COB$ runtime counterpart. All of this is automatic, so the calling code does not need manual editing.

Yes. VX/COBOL is built for continuous integration: you keep developing in VMS and OpenVMS COBOL, and each release is migrated to Linux automatically, so there is no code freeze and full functionality is preserved across the estate.

VX/COBOL routes file operations through VX/RMS, so RMS file handling works the same on Linux as it did on OpenVMS. Reads, writes, key lookups, and record locking all behave identically, and per-file RMS status is preserved for the status special registers.

Yes. As part of targeting Linux, VX/COBOL adjusts for 32-bit and 64-bit architecture differences, widening descriptors and converting stored pointers where needed, so the migrated application behaves correctly on x86 Linux.

VX/COBOL drops the OpenVMS APPLY LOCK-HOLDING clause from I-O-CONTROL and instead adds LOCK MODE IS AUTOMATIC to the affected file's SELECT in FILE-CONTROL, so record-locking behavior carries over without manual rework.

It translates OpenVMS and VAX FORTRAN into ANSI-compliant FORTRAN (Intel FORTRAN) that runs on x86 Linux and Windows. It is built on the Fortran Partner (fpt) transpiler and adds VMS-specific handling, standards adherence, and performance optimizations, so decades of FORTRAN investment move forward without manual code modifications.

Source code analysis identifies VMS-specific extensions, RMS file dependencies, and embedded Pro*FORTRAN SQL. Transpilation converts VMS extensions to ANSI-standard FORTRAN. Optimization tunes the emitted source with inline expansion and loop unrolling for Intel FORTRAN. Finally, compile and validate builds the source and runs automated test cases to confirm identical execution behaviour.

VMS file specifications are translated to host paths at run time, so standard OPEN statements keep working. Keyed and indexed (ISAM) files, along with the REWRITE, DELETE, and UNLOCK record operations, are routed to the VX/RMS runtime, which replaces obsolete ISAM handling with modern FORTRAN record I/O while preserving key structure and record locking.

VX/FORTRAN automatically converts Pro*FORTRAN SQL statements into external C functions, so database access keeps working on the target platform without hand-rewriting the embedded SQL.

Execution time can improve by up to 40 percent. The gains come from optimizations applied during migration: inline expansion of subroutines and statement functions to remove call overhead, loop unrolling, and memory-access optimizations.

Advanced static analysis flags syntax, logical, and performance issues before migration. A representative report shows missing subroutine declarations (which prevent compilation errors), inconsistent argument types (which fix potential runtime crashes), and unsafe integer-to-real conversions (which prevent loss of precision). It also flags keywords used as variable names and uninitialised variables.

Yes. VX/FORTRAN supports zero code freeze. You continue development on OpenVMS while each release is migrated to Linux and Windows in parallel, so the migration does not stall ongoing work.

Migration is 100 percent automated with no manual remediation required. For sites that need it, VX/FORTRAN can also apply security and obfuscation to protect the source code while ensuring it remains compilable.

It is an automated source-to-source translator that converts OpenVMS and VAX Pascal into ANSI-compliant C++, which then compiles, links, and runs on x86 Linux and Windows. It targets readable, maintainable C++ rather than opaque machine-generated output.

It fully supports VMS-specific extensions, including VMS stack operations, string descriptors, CDD data structures, and RMS file handling: the constructs a generic Pascal compiler would not understand, so it preserves compatibility with the original application.

Linux and Windows do not natively carry the VMS notion of an optional argument being present or absent. VX/PASCAL preserves the PRESENT and not-present semantics in the emitted C++ and its runtime, so optional-argument handling behaves as it did on OpenVMS.

No. VX/PASCAL is built for continuous migration: you can keep developing in OpenVMS Pascal while each release is migrated, with source kept synchronized between the Pascal and C++ versions and builds carried across through converted MMS and command files.

VARYING and packed string types become runtime string class templates that keep VMS length and padding semantics, and VMS string routines such as STR$CONCAT and STR$COPY are handled through the STR$ runtime and C++ operator overloading.

Through the VX/RMS runtime, the generated code supports indexed, relative, sequential, and block files, plus keyed access, RFA access, and record locking, so file behavior carries over without a data conversion step.

It integrates with VX/CDD to retain Common Data Dictionary record definitions during conversion, so CDD-defined data types and references carry through into the translated C++.

The migration process ends with an execute-and-validate step that runs automated test cases to confirm identical behavior between the original VMS Pascal and the translated C++, and any construct the translator cannot represent is named with a numbered diagnostic rather than dropped.